NOIP2011

今天GG了，一不小心写挂了。

铺地毯

【问题描述】 为了准备一个独特的颁奖典礼，组织者在会场的一片矩形区域（可看做是平面直角坐标系的第一象限）铺上一些矩形地毯。一共有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	carpet.out
3	3
1 0 2 3
0 2 3 3
2 1 3 3
2 2

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

【输入输出样例 2】

carpet.in	carpet.out
3	-1
1 0 2 3
0 2 3 3
2 1 3 3
4 5

【输入输出样例说明】 如上图，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。

题解

【一句话题意】 给定n个按顺序覆盖的矩形，求某个点最上方的矩形编号。
【思路】 好吧我承认看到图片的一瞬间想到过二维树状数组和二维线段树。 置答案ans=-1，按顺序枚举所有矩形，如果点在矩形内则更新ans。注意题中给出的不是对角坐标，实际上是(a,b)与(a+g,b+k)
复杂度O(N)

#include<cstdio>
#include<iostream>
using namespace std;
template<class T>inline void readin(T &res){
    static char ch;
    while((ch=getchar())<'0'||ch>'9');res=ch-48;
    while((ch=getchar())<='9'&&ch>='0')res=res*10+ch-48;
}
struct point{
    int x1,y1,x2,y2;
}a[10010];
int n,x,y,ans;
int main(){
    freopen("carpet.in","r",stdin);
    freopen("carpet.out","w",stdout);
    readin(n);
    for(int c,b,i=1;i<=n;i++){
        readin(a[i].x1),readin(a[i].y1);
        readin(c),readin(b);
        a[i].x2=a[i].x1+c;a[i].y2=a[i].y1+b;
    }
    readin(x),readin(y);
    for(int i=n;i>=1;i--)
        if(x>=a[i].x1&&x<=a[i].x2&&y<=a[i].y2&&y>=a[i].y1){
            cout<<i<<endl;
            return 0;
        }
    cout<<-1<<endl;
    return 0;
}

选择客栈

题目描述

丽江河边有n 家很有特色的客栈，客栈按照其位置顺序从 1 到n 编号。每家客栈都按照某一种色调进行装饰（总共 k 种，用整数 0 ~ k-1 表示），且每家客栈都设有一家咖啡店，每家咖啡店均有各自的最低消费。
两位游客一起去丽江旅游，他们喜欢相同的色调，又想尝试两个不同的客栈，因此决定分别住在色调相同的两家客栈中。晚上，他们打算选择一家咖啡店喝咖啡，要求咖啡店位于两人住的两家客栈之间（包括他们住的客栈），且咖啡店的最低消费不超过 p 。
他们想知道总共有多少种选择住宿的方案，保证晚上可以找到一家最低消费不超过 p元的咖啡店小聚。
输入输出格式
输入格式：
输入文件hotel.in，共n+1 行。
第一行三个整数n ，k ，p，每两个整数之间用一个空格隔开，分别表示客栈的个数，色调的数目和能接受的最低消费的最高值；
接下来的n 行，第 i+1 行两个整数，之间用一个空格隔开，分别表示 i 号客栈的装饰色调和i 号客栈的咖啡店的最低消费。
输出格式：
输出文件名为hotel.out 。
输出只有一行，一个整数，表示可选的住宿方案的总数。

输入输出样例
输入样例#1：
5 2 3
0 5
1 3
0 2
1 4
1 5
输出样例#1：
3

说明

【输入输出样例说明】
2 人要住同样色调的客栈，所有可选的住宿方案包括：住客栈①③，②④，②⑤，④⑤，但是若选择住4 、5 号客栈的话，4 、5 号客栈之间的咖啡店的最低消费是4 ，而两人能承受的最低消费是3 元，所以不满足要求。因此只有前 3 种方案可选。
【数据范围】
对于30% 的数据，有 n ≤100；
对于50% 的数据，有 n ≤1,000；
对于100%的数据，有 2 ≤n ≤200,000，0

题解

如果一家编号为 i 咖啡店的最低消费大于p，则记flag[ i ]=1;否则，flag[ i ]=0.
考虑到计算满足要求的对数不太容易， 从反面思考：
从1到n扫描出flag值等于1的连续客栈（在此区间内找到的客栈均为不满足要求的方案），在扫描时用cnt[j]记录当前颜色为j的客栈出现次数
cnt[j]++;count+=(cnt [j]-1); （新的客栈可以与当前任意颜色相同客栈组合）
可以数出颜色相同但不满足要求的客栈对数。
答案ans=sum-count.(sum为所有颜色相同的客栈对数)
即为满足要求的客栈对数。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
template<class T>inline void readin(T &res){
    static char ch;
    while((ch=getchar())<'0'||ch>'9');res=ch-48;
    while((ch=getchar())<='9'&&ch>='0')res=res*10+ch-48;
}
bool flag[200010];
int cnt[100],_count,sum,n,k,p,col[200010],tmp;
int main(){
    freopen("hotel.in","r",stdin);
    freopen("hotel.out","w",stdout);
    readin(n),readin(k),readin(p);
    for(register int i=1;i<=n;i++){
        readin(col[i]),readin(tmp);
        if(tmp>p)flag[i]=1;
    }
    for(register int i=1;i<=n;i++){
        if(flag[i]==0){
            memset(cnt,0,sizeof(cnt));
            continue;
        }
        cnt[col[i]]++;
        _count+=(cnt[col[i]]-1);
    }
    memset(cnt,0,sizeof(cnt));
    for(register int i=1;i<=n;i++){
        cnt[col[i]]++;
        sum+=(cnt[col[i]]-1);
    }
    cout<<sum-_count<<endl;
    return 0;
}

Mayan游戏

【问题描述】
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所示的局面。

【样例输入】
3
1 0
2 1 0
2 3 4 0
3 1 0
2 4 3 4 0
【样例输出】
2 1 1
3 1 1
3 0 1

题解

注意注意，第一页描述这题每个测试点时间限制是3S，我当时就震惊了！
首先马上确定这是搜索题目，抛弃所有动规贪心等等。然后锁定DFS，因为题中已经限定搜索深度，BFS是自找MLE。
再确定状态存储方式，我是将输入逆时针转90°后用数组保存，因此坐标之类的要特别注意。
然后，然后就没什么特别的了，搜素顺序题目已经给了。
设过程down(i)，表示将第i列的所有方块下沉。设函数clear，分行列清空后返回是否可以清空，这里用到连续区间指针l、r优化，类似前向星分组时的操作。于是：
while clear do
for i:=1 to 5 do
down(i);
注意在此之前如果有方块一交换就往下掉，那么就down交换的那两列。
表示码了200多行代码用了半小时，调试几乎用了1小时，那叫一个蛋疼。。。。
根据我的CCF测评分数可以看出，爆搜只能过50分，若常数小一点可以过80分。回家后我稍微修改了一下代码，用上了WJMZBMR的前两个剪枝，最后一个点在家里的电脑上跑了2s，其他点轻松通过了。
下面附加几个剪枝(from WJMZBMR)：
• 左右交换是等价的，根据题中的顺序，只需向右交换即可
• 某个颜色方块的数量<=2，则很显然不能被消除
• 掉落不能改变方块的列，因此某列l1上某颜色方块数量∈[1,2]，则必须通过交换来从其他列l2得到方块。取一个l1，且l2最远，设这个距离为Di，那么必须要把多有颜色的Di消到0。而一次操作最多减少两个颜色的Di，因此最少操作次数为：max{max{Di}(1<=i<=10),(sum(Di)(1<=i<=10)+1)/2}
• 设个变量掐时，大概快超时的时候直接输出-1
【时间复杂度】
O(k(4*7)^5)

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;
template<class T>inline void readin(T &res){
    static char ch;
    while((ch=getchar())<'0'||ch>'9');res=ch-48;
    while((ch=getchar())<='9'&&ch>='0')res=res*10+ch-48;
}
int n,num[15],mayan[6][8],ans[6][3];
bool judge(int mayan[6][8]){
    bool flag(0),f[6][8]={0};
    for(register int a=1;a<=5;a++)
        for(register int b=1;b<=7;b++)
            if(mayan[a][b]){
                if(a<=3&&mayan[a][b]==mayan[a+1][b]&&mayan[a+1][b]==mayan[a+2][b])
                    f[a][b]=f[a+1][b]=f[a+2][b]=1;
                if(b<=5&&mayan[a][b]==mayan[a][b+1]&&mayan[a][b+1]==mayan[a][b+2])
                    f[a][b]=f[a][b+1]=f[a][b+2]=1;
            }
    for(register int a=1;a<=5;a++)
        for(register int b=1;b<=7;b++)
            if(f[a][b]){
                mayan[a][b]=0;
                flag=1;
            }
    return flag;
}
void down(int mayan[6][8]){
    for(register int a=1;a<=5;a++){
        int t(0);
        for(register int b=1;b<=7;b++){
            int v=mayan[a][b];
            mayan[a][b]=0;
            if(v)mayan[a][++t]=v;
        }
    }
}
bool check(int mayan[6][8]){
    for(register int a=1;a<=5;a++)
        for(register int b=1;b<=7;b++)
            if(mayan[a][b])return 0;
    return 1;
}
void dfs(int T,int mayan[6][8]){
    if(T>n){
        if(check(mayan)){
            for(register int a=1;a<=n;a++)
                if (ans[a][2])printf("%d %d -1\n",ans[a][0],ans[a][1]-1);
                else printf("%d %d 1\n",ans[a][0]-1,ans[a][1]-1);
            exit(0);
        }
        return;
    }
    memset(num,0,sizeof(num));
    for(register int a=1;a<=5;a++)
        for(register int b=1;b<=7;b++)
            if(mayan[a][b])num[mayan[a][b]]++;
    for(register int a=1;a<=10;a++)
        if (num[a]==1||num[a]==2)return;
    int f[6][8]={0};
    for(register int a=1;a<5;a++)
        for(register int b=1;b<=7;b++)
        if(mayan[a][b]!=mayan[a+1][b]){
            memcpy(f,mayan,sizeof(f));
            ans[T][0]=a;ans[T][1]=b;
            ans[T][2]=!mayan[a][b]; 
            swap(f[a][b],f[a+1][b]);
            down(f);
            while (judge(f))down(f);
            dfs(T+1,f);
        }
}
int main(){
    freopen("mayan.in","r",stdin);
    freopen("mayan.out","w",stdout);
    readin(n);
    for(register int a=1;a<=5;a++)
        for(register int b=1;;b++){
            readin(mayan[a][b]);
            if (!mayan[a][b])break;
        }
    dfs(1,mayan);
    printf("-1");
    return 0;
}