NOIP2011 提高组 Day1

自测：8:27——11:51

实际得分：100+60+20=180

期望得分：100+60+40=200

T3读错题，失20

http://cogs.pro/cogs/page/page.php?aid=16

T1 铺地毯

【问题描述】 
为了准备一个独特的颁奖典礼，组织者在会场的一片矩形区域（可看做是平面直角坐标系的第一象限）铺上一些矩形地毯。一共有 n张地毯，编号从 1 到n。现在将这些地毯按照编号从小到大的顺序平行于坐标轴先后铺设，后铺的地毯覆盖在前面已经铺好的地毯之上。
地毯铺设完成后，组织者想知道覆盖地面某个点的最上面的那张地毯的编号。注意：在矩形地毯边界和四个顶点上的点也算被地毯覆盖。

【输入】 
输入文件名为 carpet.in。 
输入共 n+2行。 
第一行，一个整数 n，表示总共有 n张地毯。 
接下来的 n行中，第 i+1行表示编号 i的地毯的信息，包含四个正整数 a，b，g，k，每两个整数之间用一个空格隔开，分别表示铺设地毯的左下角的坐标（a，b）以及地毯在 x 轴和 y轴方向的长度。 
第 n+2 行包含两个正整数 x 和 y，表示所求的地面的点的坐标（x，y） 。 
【输出】 
输出文件名为 carpet.out。 
输出共 1 行，一个整数，表示所求的地毯的编号；若此处没有被地毯覆盖则输出-1。

【输入输出样例 1】

carpet.in

3 
1 0 2 3 
0 2 3 3 
2 1 3 3 
2 2

carpet.out

3

【输入输出样例说明】 
如下图，1 号地毯用实线表示，2 号地毯用虚线表示，3 号用双实线表示，覆盖点（2，2）的最上面一张地毯是 3 号地毯。

【输入输出样例 2】

carpet.in

3 
1 0 2 3 
0 2 3 3 
2 1 3 3 
4 5

carpet.out

-1

【输入输出样例说明】 
如上图，1 号地毯用实线表示，2 号地毯用虚线表示，3 号用双实线表示，点（4，5）
没有被地毯覆盖，所以输出-1。

【数据范围】 
对于 30%的数据，有 n≤2； 
对于 50%的数据，0≤a, b, g, k≤100； 
对于 100%的数据，有 0≤n≤10,000，0≤a, b, g, k≤100,000。

从后往前枚举判断

时间复杂度：O（n）

#include<cstdio>
#define N 10001
using namespace std;
int a,b,g,k,x,y,n;
int x1[N],x2[N],y1[N],y2[N];
int main()
{
    freopen("carpet.in","r",stdin);
    freopen("carpet.out","w",stdout);
    scanf("%d",&n);
    for(int i=;i<=n;i++)
    {
        scanf("%d%d%d%d",&a,&b,&g,&k);
        x1[i]=a;x2[i]=a+g;
        y1[i]=b;y2[i]=b+k;
    }
    scanf("%d%d",&x,&y);
    for(int i=n;i;i--)
    {
        if(x>=x1[i]&&x<=x2[i]&&y>=y1[i]&&y<=y2[i])
        {
            printf("%d",i);
            fclose(stdin); fclose(stdout);
            return ;
        }
    }
    printf("-1");
    fclose(stdin);fclose(stdout);
    return ;
}

T2 选择客栈

时间限制：1 s   内存限制：128 MB

【问题描述】

丽江河边有n 家很有特色的客栈，客栈按照其位置顺序从1 到n 编号。每家客栈都按照某一种色调进行装饰（总共k 种，用整数0 ~ k-1 表示），且每家客栈都设有一家咖啡店，每家咖啡店均有各自的最低消费。
两位游客一起去丽江旅游，他们喜欢相同的色调，又想尝试两个不同的客栈，因此决定分别住在色调相同的两家客栈中。晚上，他们打算选择一家咖啡店喝咖啡，要求咖啡店位于两人住的两家客栈之间（包括他们住的客栈），且咖啡店的最低消费不超过p。
他们想知道总共有多少种选择住宿的方案，保证晚上可以找到一家最低消费不超过p元的咖啡店小聚。

【输入】
输入文件hotel.in，共n+1 行。
第一行三个整数n，k，p，每两个整数之间用一个空格隔开，分别表示客栈的个数，色调的数目和能接受的最低消费的最高值；
接下来的n 行，第i+1 行两个整数，之间用一个空格隔开，分别表示i 号客栈的装饰色调和i 号客栈的咖啡店的最低消费。

【输出】
输出文件名为hotel.out。

输出只有一行，一个整数，表示可选的住宿方案的总数。

【输入输出样例1】

hotel.in

5 2 3
0 5
1 3
0 2
1 4
1 5

hotel.out

3

【输入输出样例说明】

客栈编号	①	②	③	④	⑤
色调	0	1	0	1	1
最低消费	5	3	2	4	5

2 人要住同样色调的客栈，所有可选的住宿方案包括：住客栈①③，②④，②⑤，④⑤，但是若选择住4、5 号客栈的话，4、5 号客栈之间的咖啡店的最低消费是4，而两人能承受的最低消费是3 元，所以不满足要求。因此只有前3 种方案可选。

【数据范围】
对于30%的数据，有n≤100；
对于50%的数据，有n≤1,000；
对于100%的数据，有2≤n≤200,000, 0≤K≤50，0≤P≤100， 0≤最低消费≤100, K≤50，0≤P≤100，

法一、O（nk+n）

same[i][j]表示前i个客栈中，色调为j的个数

pre[i]表示前i个客栈中，最后一个消费<=p的客栈

O（nk）预处理same[]

然后枚举客栈i

如果pre[i]=i，说明客栈i的消费<=p，那么 i 与 i前面任意一个色调为color[i]的客栈 都是合法的

所以ans+=sum[i][color[i]]-1

如果pre[i]!=i,说明客栈i的消费>p，那么 i 与 pre[i]前面任意一个色调为color[i]的客栈（包括pre[i]） 都是合法的

所以ans+=sum[pre[i]][color[i]]

#include<cstdio>
#define N 200001
using namespace std;
int n,k,p;
int same[N][],sum[],pre[N],last,co[N];
long long ans;
int main()
{
    freopen("hotel.in","r",stdin);
    freopen("hotel.out","w",stdout);
    scanf("%d%d%d",&n,&k,&p);
    int x,y;
    for(int i=;i<=n;i++)
    {
        scanf("%d%d",&x,&y);
        sum[x]++;
        co[i]=x;
        for(int j=;j<=k;j++) same[i][j]=sum[j];
        if(y<=p) last=i;
        pre[i]=last;
    }
    for(int i=;i<=n;i++)
     if(pre[i]==i) ans+=same[i][co[i]]-;
     else ans+=same[pre[i]][co[i]];
    printf("%lld",ans);
}

法二、O（n）

last[i]=j 表示当前颜色为i的 所有客栈中，最后一个的是j

lastt 表示当前所有客栈中，最后一个消费<=p的客栈

sum_tot[i]=j  表示当前颜色为i的客栈共有j个

sum[i]=j 表示当前与 颜色为i的这个客栈 可以组成的合法方案数

直接看代码吧。。

#include<cstdio>
#define N 200001
using namespace std;
int n,k,p;
int last[],lastt,sum_tot[],sum[];
long long ans;
int main()
{
    freopen("hotel.in","r",stdin);
    freopen("hotel.out","w",stdout);
    scanf("%d%d%d",&n,&k,&p);
    int x,y;
    for(int i=;i<=n;i++)
    {
        scanf("%d%d",&x,&y);
        if(y<=p) lastt=i;
        if(last[x]<=lastt) sum[x]=sum_tot[x];
        sum_tot[x]++; last[x]=i;
        ans+=sum[x];
    }
    printf("%lld",ans);
}

自测时打的n²的暴力 60分

#include<cstdio>
#include<algorithm>
#define N 200001
using namespace std;
int n,k,p;
int sum[N];
long long ans,tmp;
struct node
{
    int id,color;
}e[N];
int main()
{
    freopen("hotel.in","r",stdin);
    freopen("hotel.out","w",stdout);
    scanf("%d%d%d",&n,&k,&p);
    int x;
    for(int i=;i<=n;i++)
    {
        e[i].id=i; scanf("%d",&e[i].color);
        scanf("%d",&x);
        sum[i]=sum[i-]+(x<=p);
    }
    for(int i=;i<n;i++)
     for(int j=i+;j<=n;j++)
         if(e[i].color==e[j].color&&sum[e[j].id]-sum[e[i].id-]) ans++;
    printf("%lld",ans);
}

为什么没想出来？

1、一开始读错题，看成了选的喝咖啡的地方不同也是不同的方案

不认真读题，难道觉得自己可以轻松应对NOIP了吗？

记住SDOI2017的教训

2、开始想到的：

令f表示当前合法的方案总数，那么如果当前客栈的花费<=p，那么f中的每一种方案，拿出一个客栈都可与当前客栈形成新的方案

但这样不对，比如1 2 ，1 3， 1 4， 2 3， 2 4,3 4 各拿出一个是1 1 1 2 2  3，总之有重复

然后就不继续想了

下次思路出现问题不要弃疗，改

T3 mayan游戏

时间限制：3 s   内存限制：128 MB

【问题描述】
Mayan puzzle 是最近流行起来的一个游戏。游戏界面是一个7 行5 列的棋盘，上面堆放着一些方块，方块不能悬空堆放，即方块必须放在最下面一行，或者放在其他方块之上。游戏通关是指在规定的步数内消除所有的方块，消除方块的规则如下：
1、 每步移动可以且仅可以沿横向（即向左或向右）拖动某一方块一格：当拖动这一方块时，如果拖动后到达的位置（以下称目标位置）也有方块，那么这两个方块将交换位置（参见输入输出样例说明中的图6 到图7）；如果目标位置上没有方块，那么被拖动的方块将从原来的竖列中抽出，并从目标位置上掉落（直到不悬空，参见下面图1 和图2）；

2、 任一时刻，如果在一横行或者竖列上有连续三个或者三个以上相同颜色的方块，则它们将立即被消除（参见图1 到图3）。

注意：
a) 如果同时有多组方块满足消除条件，几组方块会同时被消除（例如下面图4，三个颜色为1 的方块和三个颜色为2 的方块会同时被消除，最后剩下一个颜色为2 的方块）。
b) 当出现行和列都满足消除条件且行列共享某个方块时，行和列上满足消除条件的所有方块会被同时消除（例如下面图5 所示的情形，5 个方块会同时被消除）。

3、 方块消除之后，消除位置之上的方块将掉落，掉落后可能会引起新的方块消除。注意：掉落的过程中将不会有方块的消除。

上面图1 到图3 给出了在棋盘上移动一块方块之后棋盘的变化。棋盘的左下角方块的坐标为（0, 0），将位于（3, 3）的方块向左移动之后，游戏界面从图1 变成图2 所示的状态，此时在一竖列上有连续三块颜色为4 的方块，满足消除条件，消除连续3 块颜色为4 的方块后，上方的颜色为3 的方块掉落，形成图3 所示的局面。

【输入】
输入文件mayan.in，共6 行。
第一行为一个正整数n，表示要求游戏通关的步数。
接下来的5 行，描述7*5 的游戏界面。每行若干个整数，每两个整数之间用一个空格隔开，每行以一个0 结束，自下向上表示每竖列方块的颜色编号（颜色不多于10 种，从1 开始顺序编号，相同数字表示相同颜色）。
输入数据保证初始棋盘中没有可以消除的方块。

【输出】
输出文件名为mayan.out。

如果有解决方案，输出n 行，每行包含3 个整数x，y，g，表示一次移动，每两个整数之间用一个空格隔开，其中（x，y）表示要移动的方块的坐标，g 表示移动的方向，1 表示向右移动，-1 表示向左移动。注意：多组解时，按照x 为第一关健字，y 为第二关健字，1优先于-1，给出一组字典序最小的解。游戏界面左下角的坐标为（0，0）。
如果没有解决方案，输出一行，包含一个整数-1。

【输入输出样例1】

mayan.in

3
1 0
2 1 0
2 3 4 0
3 1 0
2 4 3 4 0

mayan.out

2 1 1
3 1 1
3 0 1

【输入输出样例说明】
按箭头方向的顺序分别为图6 到图11

样例输入的游戏局面如上面第一个图片所示，依次移动的三步是：（2，1）处的方格向右移动，（3，1）处的方格向右移动，（3，0）处的方格向右移动，最后可以将棋盘上所有方块消除。

【数据范围】
对于30%的数据，初始棋盘上的方块都在棋盘的最下面一行；
对于100%的数据，0 < n≤5。

模拟、dfs

貌似好像只有一个剪枝：

若当前有某种颜色的方块数量为1或2，则reutrn

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int a[][],k[],ans[][];
int n,tot[];
bool ok;
void clear();
void down()//可与消除形成连锁反应的下降
{
    int sum;bool okk=false;
    for(int i=;i<;i++)
    {
        sum=;
        for(int j=;j<;j++)
        {
            if(sum==k[i]) break;
            if(a[i][j])
            {
                sum++;continue;
            }
            else
            {
                int k=j;
                while(!a[i][k]) k++;
                swap(a[i][j],a[i][k]);
                sum++;
                okk=true;
            }
        }
    }
    if(okk) clear();
}
void down2()//左移右移的下降，不消除
{
    int sum;
    for(int i=;i<;i++)
    {
        sum=;
        for(int j=;j<;j++)
        {
            if(sum==k[i]) break;
            if(a[i][j])
            {
                sum++;continue;
            }
            else
            {
                int k=j;
                while(!a[i][k]) k++;
                swap(a[i][j],a[i][k]);
                sum++;
            }
        }
    }
}
void left_down(int x,int y)//左移
{
    swap(a[x][y],a[x-][y]);
    k[x-]++;k[x]--;
    down2();
}
void right_down(int x,int y)//右移
{
    swap(a[x][y],a[x+][y]);
    k[x+]++;k[x]--;
    down2();
}
void clear()
{
    bool ok1,ok2,ok3=false;
    for(int i=;i<;i++)
     for(int j=;j<k[i];j++)
     {
         if(!a[i][j]) continue;
         ok1=ok2=false;
         int r=i+,u=j+;
         for(;r<;r++) if(a[r][j]!=a[i][j]) break; r--;//横着
         for(;u<;u++) if(a[i][u]!=a[i][j]) break; u--;//竖着
         if(r-i+>=) ok1=true;
         if(u-j+>=) ok2=true;
         if(ok1)
         {
             ok3=true;int down,up;
             for(int s=i;s<=r;s++)
              {
                  for(down=j-;down>=;down--)//只有横着的时候才有可能出现与竖着的共用的情况
                   if(a[s][j]!=a[s][down]) break;
                  down++;
                  for(up=j+;up<;up++)
                   if(a[s][j]!=a[s][up]) break;
                  up--;
                  a[s][j]=,k[s]--;
                  if(up-down+>=)
                  for(int t=down;t<=up;t++)
                    if(a[s][t])
                     a[s][t]=,k[s]--;
              }
        }
        if(ok2)
        {
            ok3=true;
            for(int t=j;t<=u;t++)
             if(a[i][t])
             {
                 a[i][t]=;  k[i]--;
             }
        }
     }
    if(ok3) down();

}
bool empty()
{
    for(int i=;i<;i++)
     for(int j=;j<;j++)
      if(a[i][j]) return false;
    return true;
}
bool check1()//若一种颜色的数量为1或2，则不合法
{
    memset(tot,,sizeof(tot));
    for(int i=;i<;i++)
     for(int j=;j<;j++)
      tot[a[i][j]]++;
    for(int i=;i<=;i++)
     if(tot[i]==||tot[i]==) return false;
    return true;
}
void dfs(int now)
{
    if(ok) return;
    if(now==n+)
    {
        if(empty())
        {
            for(int i=;i<=n;i++)
             printf("%d %d %d\n",ans[i][],ans[i][],ans[i][]);
            ok=true;
        }
        return;
    }
    if(!check1()) return;
    int b[][];int c[];
    memcpy(b,a,sizeof b);
    memcpy(c,k,sizeof c);
    for(int i=;i<;i++)
     for(int j=;j<k[i];j++)
     {
         if(!a[i][j]) continue;
         if(i!=&&a[i+][j]&&a[i][j]!=a[i+][j])//向右交换
         {
             ans[now][]=;ans[now][]=i;ans[now][]=j;
             swap(a[i][j],a[i+][j]);
             clear();
             dfs(now+);
             memcpy(a,b,sizeof a);
             memcpy(k,c,sizeof k);
         }
         else if(i!=&&a[i+][j]==&&a[i][j]!=a[i+][j]) //向右移
         {
             ans[now][]=;ans[now][]=i;ans[now][]=j;
             right_down(i,j);
             clear();
             dfs(now+);
             memcpy(a,b,sizeof a);
             memcpy(k,c,sizeof k);
         }
         if(i==&&a[i-][j]&&a[i][j]!=a[i-][j])//向左交换
         {
             ans[now][]=-;ans[now][]=i;ans[now][]=j;
             swap(a[i][j],a[i-][j]);
             clear();
             dfs(now+);
             memcpy(a,b,sizeof a);
             memcpy(k,c,sizeof k);
         }
         else if(i&&a[i-][j]==&&a[i-][j]!=a[i][j]) //向左移
         {
             ans[now][]=-;ans[now][]=i;ans[now][]=j;
             left_down(i,j);
             clear();
             dfs(now+);
             memcpy(a,b,sizeof a);
             memcpy(k,c,sizeof k);
         }
     }
}
int main()
{
    /*freopen("mayan.in","r",stdin);
    freopen("mayan.out","w",stdout);*/
    scanf("%d",&n);
    int x,j;
    for(int i=;i<;i++)
    {
        j=;
        while()
        {
            scanf("%d",&x);
            if(!x)
            {
                k[i]=j;//横坐标为i的方块数量
                break;
            }
            a[i][j]=x;
            j++;
        }
    }
    dfs();
    if(!ok) printf("-1");
    return ;
}

输出先输出坐标，在输出移动方向

不看好题，先输出了方向