NOIP2010

最后一道题WA了，用了贪心，忘了这是一道线段覆盖的问题。

机器翻译

(translate.pas/c/cpp)
【问题描述】
小晨的电脑上安装了一个机器翻译软件，他经常用这个软件来翻译英语文章。这个翻译软件的原理很简单，它只是从头到尾，依次将每个英文单词用对应的中文含义来替换。对于每个英文单词，软件会先在内存中查找这个单词的中文含义，如果内存中有，软件就会用它进行翻译；如果内存中没有，软件就会在外存中的词典内查找，查出单词的中文含义然后翻译，并将这个单词和译义放入内存，以备后续的查找和翻译。
假设内存中有M 个单元，每单元能存放一个单词和译义。每当软件将一个新单词存入内存前，如果当前内存中已存入的单词数不超过M−1，软件会将新单词存入一个未使用的内存单元；若内存中已存入M 个单词，软件会清空最早进入内存的那个单词，腾出单元来，存放新单词。
假设一篇英语文章的长度为N 个单词。给定这篇待译文章，翻译软件需要去外存查找多
少次词典？假设在翻译开始前，内存中没有任何单词。
【输入】
输入文件名为translate.in，输入文件共2 行。每行中两个数之间用一个空格隔开。
第一行为两个正整数M 和N，代表内存容量和文章的长度。
第二行为N 个非负整数，按照文章的顺序，每个数（大小不超过1000）代表一个英文单词。文章中两个单词是同一个单词，当且仅当它们对应的非负整数相同。
【输出】
输出文件translate.out 共1 行，包含一个整数，为软件需要查词典的次数。

【输入输出样例1】
translate.in
3 7
1 2 1 5 4 4 1
translate.out
5

【输入输出样例 1 说明】
整个查字典过程如下：每行表示一个单词的翻译，冒号前为本次翻译后的内存状况：
空：内存初始状态为空。
1． 1：查找单词1 并调入内存。
2． 1 2：查找单词2 并调入内存。
3． 1 2：在内存中找到单词1。
4． 1 2 5：查找单词5 并调入内存。
5． 2 5 4：查找单词4 并调入内存替代单词1。
6． 2 5 4：在内存中找到单词4。
7． 5 4 1：查找单词1 并调入内存替代单词2。
共计查了5 次词典。

【输入输出样例2】
translate.in
2 10
8 824 11 78 11 78 11 78 8 264
translate.out
6

【数据范围】
对于10%的数据有M=1，N≤ 5。
对于100%的数据有0

题解

set+queue乱搞就行了，水水水！！！

#include<set>
#include<queue>
#include<cstdio>
#include<iostream>
using namespace std;
queue<int> q;
set<int> p;
int tot=0,ans=0,m,n;
int main(){
    freopen("translate.in","r",stdin);
    freopen("translate.out","w",stdout);
    scanf("%d%d",&m,&n);
    for(int x,i=1;i<=n;i++){
        scanf("%d",&x);
        if(p.find(x)==p.end()){
            p.insert(x);q.push(x);
            tot++;ans++;
        }
        if(tot>m){
            x=q.front();q.pop();
            p.erase(x);tot--;
        }
    }
    cout<<ans<<endl;
    return 0;
}

乌龟棋

(tortoise.pas/c/cpp)
【问题描述】
小明过生日的时候，爸爸送给他一副乌龟棋当作礼物。
乌龟棋的棋盘是一行N 个格子，每个格子上一个分数（非负整数）。棋盘第1 格是唯一
的起点，第N 格是终点，游戏要求玩家控制一个乌龟棋子从起点出发走到终点。
……
1 2 3 4 5 …… N
乌龟棋中M 张爬行卡片，分成4 种不同的类型（M 张卡片中不一定包含所有4 种类型的卡片，见样例），每种类型的卡片上分别标有1、2、3、4 四个数字之一，表示使用这种卡片后，乌龟棋子将向前爬行相应的格子数。游戏中，玩家每次需要从所有的爬行卡片中选择一张之前没有使用过的爬行卡片，控制乌龟棋子前进相应的格子数，每张卡片只能使用一次。
游戏中，乌龟棋子自动获得起点格子的分数，并且在后续的爬行中每到达一个格子，就得到该格子相应的分数。玩家最终游戏得分就是乌龟棋子从起点到终点过程中到过的所有格子的分数总和。
很明显，用不同的爬行卡片使用顺序会使得最终游戏的得分不同，小明想要找到一种卡片使用顺序使得最终游戏得分最多。
现在，告诉你棋盘上每个格子的分数和所有的爬行卡片，你能告诉小明，他最多能得到
多少分吗？
【输入】
输入文件名tortoise.in。输入文件的每行中两个数之间用一个空格隔开。
第1 行2 个正整数N 和M，分别表示棋盘格子数和爬行卡片数。
第2 行N 个非负整数，a1, a2, ……, aN，其中ai 表示棋盘第i 个格子上的分数。
第3 行M 个整数，b1,b2, ……, bM，表示M 张爬行卡片上的数字。
输入数据保证到达终点时刚好用光M 张爬行卡片，即N−1=$\sum_{1}^M b_i$。
【输出】
输出文件名tortoise.out。
输出只有1 行，1 个整数，表示小明最多能得到的分数。

【输入输出样例1】
tortoise.in
9 5
6 10 14 2 8 8 18 5 17
1 3 1 2 1
tortoise.out
73

【输入输出样例 1 说明】
小明使用爬行卡片顺序为1，1，3，1，2，得到的分数为6+10+14+8+18+17=73。注意，
由于起点是1，所以自动获得第1 格的分数6。

【输入输出样例2】
tortoise.in
13 8
4 96 10 64 55 13 94 53 5 24 89 8 30
1 1 1 1 1 2 4 1
tortoise.out
455

【数据范围】
对于30%的数据有1 ≤ N≤ 30，1 ≤M≤ 12。
对于50%的数据有1 ≤ N≤ 120，1 ≤M≤ 50，且4 种爬行卡片，每种卡片的张数不会超
过20。
对于100%的数据有1 ≤ N≤ 350，1 ≤M≤ 120，且4 种爬行卡片，每种卡片的张数不会
超过40；0 ≤ ai ≤ 100，1 ≤ i ≤ N；1 ≤ bi ≤ 4，1 ≤ i ≤M。输入数据保证N−1=N−1=$\sum_{1}^M b_i$。

题解

因为每种牌的数量小于40，所以就可以用四维dp秒解。
以f[i][j][k][p]来表示四种牌去i,j,k,p张是的最大收益就可以了。

#include<cstdio>
#include<iostream>
#define res(x,y) for(int x=0;x<=y;x++)
using namespace std;
int n,m,f[45][45][45][45],a[400],c[5];
int main(){
    freopen("tortoise.in","r",stdin);
    freopen("tortoise.out","w",stdout);
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)scanf("%d",&a[i]);
    for(int x,i=1;i<=m;i++)scanf("%d",&x),c[x]++;
    res(i,c[1])res(j,c[2])res(k,c[3])res(p,c[4]){
        int a1=i==0?0:f[i-1][j][k][p];
        int a2=j==0?0:f[i][j-1][k][p];
        int a3=k==0?0:f[i][j][k-1][p];
        int a4=p==0?0:f[i][j][k][p-1];
        int t=max(max(a1,a2),max(a3,a4));
        f[i][j][k][p]=t+a[1*i+2*j+3*k+4*p+1];
    }
    cout<<f[c[1]][c[2]][c[3]][c[4]]<<endl;
    return 0;
}

关押罪犯

(prison.pas/c/cpp)
【问题描述】
S 城现有两座监狱，一共关押着N 名罪犯，编号分别为1~N。他们之间的关系自然也极不和谐。很多罪犯之间甚至积怨已久，如果客观条件具备则随时可能爆发冲突。我们用“怨气值”（一个正整数值）来表示某两名罪犯之间的仇恨程度，怨气值越大，则这两名罪犯之间的积怨越多。如果两名怨气值为c 的罪犯被关押在同一监狱，他们俩之间会发生摩擦，并造成影响力为c 的冲突事件。
每年年末，警察局会将本年内监狱中的所有冲突事件按影响力从大到小排成一个列表，然后上报到S 城Z 市长那里。公务繁忙的Z 市长只会去看列表中的第一个事件的影响力，如果影响很坏，他就会考虑撤换警察局长。
在详细考察了N 名罪犯间的矛盾关系后，警察局长觉得压力巨大。他准备将罪犯们在
两座监狱内重新分配，以求产生的冲突事件影响力都较小，从而保住自己的乌纱帽。假设只要处于同一监狱内的某两个罪犯间有仇恨，那么他们一定会在每年的某个时候发生摩擦。那么，应如何分配罪犯，才能使Z 市长看到的那个冲突事件的影响力最小？这个最小值是多少？
【输入】
输入文件名为prison.in。输入文件的每行中两个数之间用一个空格隔开。
第一行为两个正整数N 和M，分别表示罪犯的数目以及存在仇恨的罪犯对数。
接下来的M 行每行为三个正整数aj，bj，cj，表示aj 号和bj 号罪犯之间存在仇恨，其怨
气值为 cj。数据保证 a b N j j 1 ≤ < ≤ ，0 < ≤ 1,000,000,000 j c ，且每对罪犯组合只出现一
次。
【输出】
输出文件prison.out 共1 行，为Z 市长看到的那个冲突事件的影响力。如果本年内监狱中未发生任何冲突事件，请输出0。

【输入输出样例】
prison.in、
4 6
1 4 2534
2 3 3512
1 2 28351
1 3 6618
2 4 1805
3 4 12884
prison.out
3512

【输入输出样例说明】
罪犯之间的怨气值如下面左图所示，右图所示为罪犯的分配方法，市长看到的冲突事件

影响力是3512（由2 号和3 号罪犯引发）。其他任何分法都不会比这个分法更优。
【数据范围】
对于30%的数据有N≤ 15。
对于70%的数据有N≤ 2000，M≤ 50000。
对于100%的数据有N≤ 20000，M≤ 100000。

题解

二分暴力可以过，然而我用并查集。开一个镜像 N来代表当f[x]!=f[y]时若将其连接的情况。

#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
int f[60010],n,m;
struct node{
    int x,y,z;
    bool operator < (const node &rhs)const {return z>rhs.z;}
}p[100010];
int find(int x){return f[x]==x?x:x=find(f[x]);}
int main(){
    freopen("prison.in","r",stdin);freopen("prison.out","w",stdout);
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n*2+10;i++)f[i]=i;
    for(int i=1;i<=m;i++)scanf("%d%d%d",&p[i].x,&p[i].y,&p[i].z);
    sort(p+1,p+1+m);
    for(int i=1;i<=m;i++){
        int x=find(p[i].x),y=find(p[i].y);
        if(x==y){cout<<p[i].z<<endl;return 0;}
        f[x]=find(p[i].y+n),f[y]=find(p[i].x+n);
    }
    cout<<0<<endl;
    return 0;
}

4.引水入城

(flow.pas/c/cpp)
【问题描述】
在一个遥远的国度，一侧是风景秀美的湖泊，另一侧则是漫无边际的沙漠。该国的行政区划十分特殊，刚好构成一个 N 行 M 列的矩形，如上图所示，其中每个格子都代表一座城市，每座城市都有一个海拔高度。
为了使居民们都尽可能饮用到清澈的湖水，现在要在某些城市建造水利设施。水利设施有两种，分别为蓄水厂和输水站。蓄水厂的功能是利用水泵将湖泊中的水抽取到所在城市的蓄水池中。因此，只有与湖泊毗邻的第 1 行的城市可以建造蓄水厂。而输水站的功能则是通过输水管线利用高度落差，将湖水从高处向低处输送。故一座城市能建造输水站的前提，是存在比它海拔更高且拥有公共边的相邻城市，已经建有水利设施。
由于第 N 行的城市靠近沙漠，是该国的干旱区，所以要求其中的每座城市都建有水利设施。那么，这个要求能否满足呢？如果能，请计算最少建造几个蓄水厂；如果不能，求干旱区中不可能建有水利设施的城市数目。

【输入】

输入文件名为flow.in。输入文件的每行中两个数之间用一个空格隔开。
输入的第一行是两个正整数 N 和 M，表示矩形的规模。
接下来 N 行，每行 M 个正整数，依次代表每座城市的海拔高度。
【输出】
输出文件名为flow.out。
输出有两行。如果能满足要求，输出的第一行是整数 1，第二行是一个整数，代表最少建造几个蓄水厂；如果不能满足要求，输出的第一行是整数0，第二行是一个整数，代表有几座干旱区中的城市不可能建有水利设施。

【输入输出样例1】
flow.in
2 5
9 1 5 4 3
8 7 6 1 2
flow.out
1
1
【样例1 说明】

只需要在海拔为9 的那座城市中建造蓄水厂，即可满足要求。

【输入输出样例2】
flow.in
3 6
8 4 5 6 4 4
7 3 4 3 3 3
3 2 2 1 1 2
flow.out
1
3

【样例2 说明】

上图中，在 3 个粗线框出的城市中建造蓄水厂，可以满足要求。以这3 个蓄水厂为源头

在干旱区中建造的输水站分别用 3 种颜色标出。当然，建造方法可能不唯一。

【数据范围】

本题共有10 个测试数据，每个数据的范围如下表所示：

//就写dfs，加点优化，险过3rd。
//最好加个read优化。
#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;
struct factory{
     long l,r;
}p[501];

long n,m,map[501][501],f[501],cnt=0;

bool vis[501][501]={0},ans[501]={0};


bool comp(const factory &a,const factory &b)
{
    return a.l<b.l;
}

void dfs(long x,long y,long ori)
{
     vis[x][y]=1;
     if(x==m){
          ans[y]=1;
          p[ori].l=min(p[ori].l,y);
          p[ori].r=max(p[ori].r,y);
     }
     if(map[x+1][y]<map[x][y]&&x!=m&&!vis[x+1][y])dfs(x+1,y,ori);
     if(map[x-1][y]<map[x][y]&&x!=1&&!vis[x-1][y])dfs(x-1,y,ori);
     if(map[x][y+1]<map[x][y]&&y!=n&&!vis[x][y+1])dfs(x,y+1,ori);
     if(map[x][y-1]<map[x][y]&&y!=1&&!vis[x][y-1])dfs(x,y-1,ori);
}

int main()
{
     cin>>m>>n;
     for(register long i=1;i<=n;++i)p[i].l=f[i]=30000;
     f[0]=0;
     for(register long i=1;i<=m;++i)
          for(register long j=1;j<=n;++j)cin>>map[i][j];
     for(register long i=1;i<=n;++i){
          dfs(1,i,i);
          memset(vis,0,sizeof(vis));
     }
     for(register long i=1;i<=n;++i)
          if(!ans[i])++cnt;
     if(cnt)cout<<0<<endl<<cnt;
     else{
          cout<<1<<endl;
          for(register long i=1;i<=n;++i)
               for(register long j=1;j<=n;++j){
                    if(i>=p[j].l&&i<=p[j].r)f[i]=min(f[i],f[p[j].l-1]+1);
              }
     cout<<f[n];
     }
     return 0;
}

//bfs就稳定多了。
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#define mod 1000000007
using namespace std;
int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
int xx[4]={1,-1,0,0},yy[4]={0,0,1,-1};
int n,m;
int a[505][505],mp[505][505],l[505][505],r[505][505];
int qx[250005],qy[250005];
struct data{int l,r;}c[505];
bool operator<(data a,data b)
{
    return a.l==b.l?a.r<b.r:a.l<b.l;
}
void bfs(int b[505][505],int x,int y,int v,bool f)
{
    int head=0,tail=1;
    qx[0]=x;qy[0]=y;b[x][y]=v;
    while(head!=tail)
    {
        int x=qx[head],y=qy[head];head++;
        for(int k=0;k<4;k++)
        {
            int nowx=x+xx[k],nowy=y+yy[k];
            if(nowx<1||nowy<1||nowx>n||nowy>m||b[nowx][nowy])continue;
            if(f==0&&a[nowx][nowy]>=a[x][y])continue;
            if(f==1&&a[nowx][nowy]<=a[x][y])continue;
            b[nowx][nowy]=b[x][y];
            qx[tail]=nowx;qy[tail]=nowy;tail++;
        }
    }
}
int main()
{
    n=read();m=read();
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            a[i][j]=read();
    for(int i=1;i<=m;i++)
        bfs(mp,1,i,1,0);
    int tot=0;
    for(int i=1;i<=m;i++)
        if(!mp[n][i])tot++;
    if(tot)
    {
        printf("0\n%d\n",tot);
        return 0;
    }
    for(int i=1;i<=m;i++)if(!l[n][i])bfs(l,n,i,i,1);
    for(int i=m;i;i--)if(!r[n][i])bfs(r,n,i,i,1);
    for(int i=1;i<=m;i++)
    {
        if(!l[1][i])l[1][i]=r[1][i];
        if(!r[1][i])r[1][i]=l[1][i];
        c[i].l=l[1][i];c[i].r=r[1][i];
    }
    int now=0,to=0;
    sort(c+1,c+m+1);
    for(int i=1;i<=m;i++)
    {
        if(now+1>=c[i].l)to=max(to,c[i].r);
        else now=to,to=max(to,c[i].r),tot++;
    }
    if(now!=m)tot++;
    printf("1\n%d\n",tot);
    return 0;
}