C++博客-【♂Not The Triumph♂O(∩_∩)O哈哈~But The Struggle♂】-文章分类-算法&例题

【DFSID 埃及分数】

开拓者 — Sat, 19 Sep 2009 11:11:00 GMT

描述 Description
在古埃及，人们使用单位分数的和(形如1/a的, a是自然数)表示一切有理数。如：2/3=1/2+1/6,但不允许2/3=1/3+1/3,因为加数中有相同的。对于一个分数a/b,表示方法有很多种，但是哪种最好呢？首先，加数少的比加数多的好，其次，加数个数相同的，最小的分数越大越好。
如：19/45=1/3 + 1/12 + 1/180
19/45=1/3 + 1/15 + 1/45
19/45=1/3 + 1/18 + 1/30,
19/45=1/4 + 1/6 + 1/180
19/45=1/5 + 1/6 + 1/18.
最好的是最后一种，因为1/18比1/180,1/45,1/30,1/180都大。
给出a,b(0

输入：a b
输出：若干个数，自小到大排列，依次是单位分数的分母。

样例输入 Sample Input
19 45

样例输出 Sample Output
5 6 18

时间限制 Time Limitation
各个测试点1s

来源 Source
from OIBH 信息学练习赛 #1 第三题

【参考程序】：

#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<iostream>
using namespace std;

__int64 best[1010],ans[1010];
__int64 n,m;
int k,found=0;
int gcd(__int64 a,__int64 b)
{
    __int64 t;
    while (b)
    {
        t=a; a=b; b=t%b;
    }
    return a;
}
void dfs(__int64 x,__int64 y,int dep)
{
    if (dep==k)
    {
        if (x==1 && y>0 && best[dep-1]<y)
        {
            best[dep]=y;
            if (ans[dep]>best[dep])
            {
                for (int i=1;i<=dep;i++) ans[i]=best[i];
                found=1;
            }
            if (dep==1 && found)
            {
                printf("%I64d\n",y);
                exit(0);
            }
        }
        return ;
    }
    if (dep>k) return ;
    __int64 xx,yy,f,t,gg;
    f=y/x+1; t=(k-dep+1)*y/x+1;
    for (int i=f;i<=t;i++)
        if (i>best[dep-1])
        {
            best[dep]=i;
            xx=x*i-y; yy=y*i;
            gg=gcd(xx,yy);
            xx/=gg; yy/=gg;
            dfs(xx,yy,dep+1);
        }
    if (found && dep==1)
    {
        for (int i=1;i<=k-1;i++) printf("%I64d ",ans[i]);
        printf("%I64d\n",ans[k]);
        exit(0);
    }
}
int main()
{
    scanf("%I64d%I64d",&n,&m);
    __int64 g;
    g=gcd(n,m);
    n/=g; m/=g;
    for (k=1;;k++)
    {
        memset(best,0,sizeof(best));
        memset(ans,127,sizeof(ans));
        dfs(n,m,1);
    }
    return 0;
}

开拓者 2009-09-19 19:11 发表评论

【DFS 笨笨的炸弹安置(赛)】

开拓者 — Sat, 12 Sep 2009 12:59:00 GMT

背景 Background
笨笨：哼哼哼……今天要干点坏事~
路人甲：0o。(-. - )
笨笨：哈哈哈……看我怎么干坏事吧~(炸弹已安置)
路人甲：啊？！什么什么？你刚刚说什么？
笨笨：切，不理你了……闪人……

描述 Description
现在笨笨有多个正方形的区域要炸——用那经典的按密码的小方块……在这些区域中原有多个引爆点，但是这些引爆点只能引爆所在的一个方形区域（区域大小不限，具体看样例），并且不能和另一个引爆点同时引爆同一个区域。笨笨想知道，在所有的正方形区域中，有哪些是可以一次炸完的。

输入格式 Input Format
输入第一行是正方形区域的个数，为了不太累，个数在50个以内。
然后是对这些正方形区域的描述，各个描述格式如下：
第一行两个数L（00）。L表示正方形区域的边长，N表示该正方形区域内引爆点个数。
接下来N行每行两个数X，Y（0

输出格式 Output Format
对于每一个正方形区域，输出一个"Yes"或一个"No"，表示能否一次引爆这个区域。
对于每个正方形区域输出一行。

样例输入 Sample Input
1
5 8
2 4
3 3
3 4
3 5
4 2
4 4
4 5
5 5

样例输出 Sample Output
Yes

时间限制 Time Limitation
1s

对于样例：
引爆点分布图
+-----+
|.....|
|...*.|
|..***|
|.*.**|
|....*|
+-----+

区域分割图
+-----+
|11122|
|11122|
|11134|
|55667|
|55668|
+-----+
在这样的分割下，这个正方形区域可以被一次引爆。

分析：
dfs搜索题。
1.如果这个框中，没有炸弹，那么继续拉大正方形框。
2.如果这个框中有一个炸弹，那就可以递归了，当做这个框里的格子全被这个炸弹炸掉了。
3.如果这个正方形框里有多于一个炸弹，或者这个正方形框里的某些格子以前已经被标记过了(这个地方只要判断一个格子就可以了，程序中我会做标注)，那就无解回溯(记得要把这次搜索的标记改回来)

【参考程序】：

#include<cstring>
#include<cstdio>
#include<iostream>
using namespace std;

int a[30][30];
bool no[30][30];
bool ok;
int N,L;
void Init()
{
    scanf("%d%d",&L,&N);
    memset(a,0,sizeof(a));
    int x,y;
    for (int i=1;i<=N;i++)
    {
        scanf("%d%d",&x,&y);
        a[x][y]=1;
    }
    for (int i=1;i<=L;i++)
        for (int j=1;j<=L;j++)
            a[i][j]+=a[i-1][j]+a[i][j-1]-a[i-1][j-1];
}
void dfs(int x,int y)
{
    if (ok) return ;
    if (x>L)
    {
        ok=true; return ;
    }
    int o,k,m; bool check;
    if (no[x][y])
    {
        if (y>=L) dfs(x+1,1);
        else dfs(x,y+1);
    }
    else
    {
        check=true;
        o=L-x+1;
        if (L-y+1<o) o=L-y+1;
        for (int p=1;p<=o;p++)
        {
            if (no[x][y+p-1])
            {
                check=false; k=p;
                break;
            }
            m=a[x+p-1][y+p-1]-a[x+p-1][y-1]-a[x-1][y+p-1]+a[x-1][y-1];
            if (m>1)
            {
                check=false; k=p;
                break;
            }
            else
            {
                for (int i=x;i<=x+p-1;i++)
                    no[i][y+p-1]=true;
                for (int i=y;i<=y+p-2;i++)
                    no[x+p-1][i]=true;
                if (m==1)
                {
                    if (y+p>L) dfs(x+1,1);
                    else dfs(x,y+p);
                }
                if (ok) return ;
            }
        }
        if (!check) k--;
        else k=o;
        for (int i=x;i<=x+k-1;i++)
            for (int j=y;j<=y+k-1;j++)
                no[i][j]=false;
    }
}
int main()
{
    int test;
    scanf("%d",&test);
    while (test)
    {
        Init();
        memset(no,false,sizeof(no));
        ok=false;
        dfs(1,1);
        if (!ok) printf("No\n");
        else printf("Yes\n");
        test--;
    }
    return 0;
}

开拓者 2009-09-12 20:59 发表评论

【DFS 尾声-怪盗基德的逃离】

开拓者 — Thu, 10 Sep 2009 12:56:00 GMT

http://www.vijos.cn/Problem_Show.asp?id=1399
背景 Background
怪盗基德第四次拿着战利品信心满满地离开了OIBH总部，一路上大摇大摆，好不嚣张。OIBH的人看不下去又没办法，打算作罢，可是有一天……当当当当……当OIBH总部的吃饭铃声响起的时候，所有正在埋头工作的大牛们都以迅雷不及掩耳盗铃之势向食堂冲去。食堂的大门顿时被人群塞的鼓鼓的(可怜ing...)当大牛们正在全力消灭由水稻演变而来的那东西时，突然走进来一个玉树临风英俊潇洒人见人爱花见花开啤酒见啤酒盖开的大帅哥(啊啊啊啊啊啊啊啊啊啊……)，而他自称是一个超超超级大牛！！超超超级大牛在听说了怪盗基德的事情后，二话不说，提笔“刷刷”的写了一页纸，其余大牛们研究了九天九夜，终于明白了纸上写的是什么，那是一个(咳咳)专门对付怪盗基德的陷阱！而怪盗基德在毫不知情的情况下，竟然把四块宝石都送回了OIBH总部，还留下预告函，将向第五块宝石发起攻势！大牛们气愤而又坏笑着，悄悄地设下了陷阱……结果出乎所有人的意料，宝石还是被拿走了，可是，为什么大牛们还在阴笑……难不成，他们在怪盗基德逃离的路上设下了陷阱?

描述 Description
果然，基德的撤退路上被布置一个巨大的迷宫。这迷宫是一个巨大的道路网，每条路上基德需要花费的时间都不同，而每条路都需要不同的过路费。这个道路网可以看做一个无向图，其中共有n个结点，共m对结点间有通路。1号结点是入口，n号结点是出口。现在要求你在规定时间内，花去尽可能多的钱(据说不这样做就不是基德的性格)帮助基德走过迷宫。注意：每条路只能走一次，走到终点即结束而不能往回走。在钱数相同的情况下使时间尽量短。

输入格式 Input Format
第一行4个整数n,m,t,v，分别是结点总数，通路总数，规定时间，及基德所拥有的钱。接下去m行，每行4个整数a,b,c,d，a和b表示有通路的两结点，c为此路费时，d代表此路过路费。

输出格式 Output Format
输出共2个整数t2,v2，分别表示用时和所剩钱数。你要保证t2<=t且v2>=0。

样例输入 Sample Input
8 10 10 120
1 2 2 1
1 3 1 1
1 4 2 19
2 3 2 6
3 4 1 1
3 5 2 2
5 6 2 1
6 7 1 3
7 8 3 1
4 8 7 100

样例输出 Sample Output
9 1

时间限制 Time Limitation
每个点1s

注释 Hint
2<=n<=100 1<=t,v<=500

样例说明
道路网如图所示【道路上括号外为费时，括号内为过路费】

1->4->8即为所求路径，用时为9，费钱为119。

分析：
DFS搜索题，题目规定每条边只可行走一次，并且图是双向的。

开个vis数组: vis[i][j]表示(i,j)是否走过。
开个g数组: g[i][j]表示(i,j)有边连接。
最后DFS，没当到达n是则询问产生的的结果是否比当前的更优(注意题目给出的比较方式)

【参考程序】：

#include<cstring>
#include<cstdio>
#include<iostream>
using namespace std;

bool vis[110][110],g[110][110];
int cost[110][110],times[110][110];
int n,m,t,v,ansc,anst;
void dfs(int now,int ts,int cs)
{
    if (now==n)
    {
        if (cs<ansc && cs>=0 && ts<=t)
        {
            ansc=cs; anst=ts;
        }
        else if (cs==ansc && ts<anst) anst=ts;
        return ;
    }
    for (int i=1;i<=n;i++)
        if (!vis[now][i] && g[now][i])
        {
            vis[now][i]=vis[i][now]=true;
            dfs(i,ts+times[now][i],cs-cost[now][i]);
            vis[now][i]=vis[i][now]=false;
        }
}
int main()
{
    scanf("%d%d%d%d",&n,&m,&t,&v);
    memset(vis,false,sizeof(vis));
    memset(g,false,sizeof(g));
    int a,b,c,d;
    for (int i=1;i<=m;i++)
    {
        scanf("%d%d%d%d",&a,&b,&c,&d);
        g[a][b]=g[b][a]=true;
        cost[a][b]=cost[b][a]=d;
        times[a][b]=times[b][a]=c;
    }
    ansc=anst=0xFFFFFFF;
    dfs(1,0,v);
    printf("%d %d\n",anst,ansc);
    return 0;
}

开拓者 2009-09-10 20:56 发表评论

【BFS 毒药?解药?】

开拓者 — Tue, 08 Sep 2009 13:14:00 GMT

http://www.vijos.cn/Problem_Show.asp?id=1026

描述 Description
羽毛笔和im是抽签到同一个考场的，她们突然闻到一阵刺鼻的化学试剂的气味。机灵鼠：(头都不抬)你们是考生么?还在门口磨蹭什么?快进来帮我忙!!……怎么还不进来?你们拖赛，拖赛，把你们的青春都拖掉赛……
im：开…开策了>_<
羽毛笔：哎呀~~机灵鼠大人要我们帮什么忙?^^

机灵鼠：你们看这里的这些药，都是我研制的对付各种症状的解药。可是我一个不小心，每种药都小小地配错了一点原料，所以这些药都有可能在治愈某些病症的同时又使人患上某些别的病症……(im：那…那是解药还是毒药啊?)……经过我天才的努力(背景：我是天才！！)，终于弄清了每种药的具体性能(路人甲：那是你自己配的吗？-_-)，我会把每种药能治的病症和能使人患上的病症列一张清单给你们，然后你们要根据这张清单找出能治愈所有病症的最少药剂组合……顺便说一声，病症的数目不超过10种(小呆：偶是好人吧^^)，我的药是用不完的，就是说每种药剂都可以被重复使用。给你们的单子里第一行是病症的总数n，第二行是药剂的种类m(0

给你们个样例：

样例输入 Sample Input
3
2
1 0 1
-1 1 0

样例输出 Sample Output
2

时间限制 Time Limitation
各个测试点1s

注释 Hint

其实还有可能用尽了所有的药也不能将所有病治愈(真是不好意思嗬^^bb).im：做不出来啊~~哇啊啊啊~~(暴走中)羽毛笔：哎呀~~im……来来吃药了。^^

来源 Source
Vivian Snow
From 正·蠢盟演义——战略版 Fools-League Tactics

分析：
以人是否健康为状态(0 or 1),则状态数最大为2^10种,再BFS,并且将二进制转换为十进制利用hash判重,找到解即可输出。

【参考程序】：

#include<cstring>
#include<cstdio>
#include<iostream>
using namespace std;

struct node
{
    int dep;
    int b[11];
} list[1025];
int F[11];
bool hash[1025];
int a[1025][11];
int n,m;
int main()
{
    F[1]=1;
    for (int i=2;i<=10;i++) F[i]=F[i-1]*2;
    scanf("%d%d",&n,&m);
    for (int i=1;i<=m;i++)
        for (int j=1;j<=n;j++)
            scanf("%d",&a[i][j]);
    int xx,tt,head,tail;
    xx=0;
    for (int i=1;i<=n;i++) xx+=F[i];
    memset(hash,false,sizeof(hash));
    memset(list,0,sizeof(list));
    head=tail=1;
    while (head<=tail)
    {
        for (int i=1;i<=m;i++)
        {
            tail++;
            tt=0;
            for (int j=1;j<=n;j++)
            {
                if (a[i][j]==1) list[tail].b[j]=1;
                if (a[i][j]==0) list[tail].b[j]=list[head].b[j];
                if (a[i][j]==-1) list[tail].b[j]=0;
                if (list[tail].b[j]==1) tt+=F[j];
            }
            if (!hash[tt])
            {
                hash[tt]=true;
                list[tail].dep=list[head].dep+1;
                if (tt==xx)
                {
                    printf("%d\n",list[tail].dep);
                    return 0;
                }
            }
            else tail--;
        }
        head++;
    }
    printf("The patient will be dead.\n");
    return 0;
}

开拓者 2009-09-08 21:14 发表评论

【记忆化搜索 Function(Function(F...】

开拓者 — Mon, 07 Sep 2009 12:50:00 GMT

http://www.vijos.cn/Problem_Show.asp?id=1080

描述 Description
对于一个递归函数w(a,b,c)
如果a<=0 or b<=0 or c<=0就返回值1.
如果a>20 or b>20 or c>20就返回w(20,20,20)
如果a其它别的情况就返回w(a-1,b,c)+w(a-1,b-1,c)+w(a-1,b,c-1)-w(a-1,b-1,c-1)
这是个简单的递归函数，但实现起来可能会有些问题。当a,b,c均为15时，调用的次数将非常的多。你要想个办法才行.

输入格式 Input Format
会有若干行a,b,c,并以-1，-1，-1结束.

输出格式 Output Format
输出若干行

样例输入 Sample Input
1 1 1
2 2 2
-1 -1 -1

样例输出 Sample Output
w(1, 1, 1) = 2
w(2, 2, 2) = 4

来源 Source
Huyichen

分析：
此题不失为一道好的记忆化题目，对于每个产生过的都记录下来，对于后面访问用的就可以直接返回上一层，无需继续DFS下去。

【参考程序】：

#include<cstring>
#include<cstdio>
#include<iostream>
using namespace std;

int F[22][22][22];
bool ok[22][22][22];
int a,b,c;
void Init()
{
    memset(ok,false,sizeof(ok));
    for (int i=0;i<=20;i++)
        for (int j=0;j<=20;j++)
            for (int k=0;k<=20;k++)
            {
                F[0][i][j]=1; ok[0][i][j]=true;
                F[i][0][j]=1; ok[i][0][j]=true;
                F[i][j][0]=1; ok[i][j][0]=true;
            }
}
int dfs(int i,int j,int k)
{
    if (ok[i][j][k]) return F[i][j][k];
    if (i<j && j<k)
    {
        F[i][j][k]=dfs(i,j,k-1)+dfs(i,j-1,k-1)-dfs(i,j-1,k);
        ok[i][j][k]=true;
        return F[i][j][k];
    }
    F[i][j][k]=dfs(i-1,j,k)+dfs(i-1,j-1,k)+dfs(i-1,j,k-1)-dfs(i-1,j-1,k-1);
    ok[i][j][k]=true;
    return F[i][j][k];
}
int main()
{
    Init();
    while (scanf("%d%d%d",&a,&b,&c)!=EOF)
    {
        if (a==-1 && b==-1 && c==-1) break;
        printf("w(%d, %d, %d) = ",a,b,c);
        if (a<1 || b<1 || c<1)
        {
            printf("1\n");
            continue;
        }
        if (a>20 || b>20 || c>20)
            printf("%d\n",dfs(20,20,20));
        else printf("%d\n",dfs(a,b,c));
    }
    return 0;
}

开拓者 2009-09-07 20:50 发表评论

【DFS 拯救ice-cream】

开拓者 — Sat, 29 Aug 2009 01:45:00 GMT

背景 Background
天好热……Tina顶着那炎炎的烈日，向Ice-cream home走去……
可是……停电了……
冰淇淋们躺在Ice-cream home的冰柜里，慢慢地……慢慢地……融化…………
你说，她能赶在冰淇淋融化完之前赶到Ice-cream home去吗?

描述 Description
给你一张坐标图，s为Tina的初始位置，m为Ice-cream home的位置，‘.’为路面，Tina在上面，每单位时间可以移动一格；‘#’为草地，Tina在上面，每两单位时间可以移动一格(建议不要模仿—毕竟 Tina还小)；‘o’是障碍物，Tina不能在它上面行动。也就是说，Tina只能在路面或草地上行走，必须绕过障碍物，并到达冰淇淋店。但是………… 不保证到达时，冰淇淋还未融化，所以……就请聪明的你……选择最佳的方案啦…………如果，Tina到的时候，冰淇淋已经融化完了，那她可是会哭的。

输入格式 Input Format
依次输入冰淇淋的融化时间t(0

输出格式 Output Format
判断按照最优方案是否可以赶在冰淇淋融化之前到达冰淇淋店(注：当T=最优方案所用时间，则判断为未赶到)，如赶到，输出所用时间；如未赶到，输出Tina的哭声——“55555”(不包括引号)。

样例输入 Sample Input
11
10
8
......s...
..........
#ooooooo.o
#.........
#.........
#.........
#.....m...
#.........

样例输出 Sample Output
10

时间限制 Time Limitation
各个测试点1s

分析：
简单的DFS练习题。
用F[x][y]表示达到(x,y)点的最小步数，用DFS拓展所有的字状态，记录每个点的最优值即可。

【参考程序】：

#include<cstring>
#include<cstdio>
#include<iostream>
using namespace std;

const int dx[4]={-1,0,1,0};
const int dy[4]={0,1,0,-1};
char map[30][30];
int F[30][30];
int n,m,t,bx,by,ex,ey;
bool check(int x,int y)
{
    if (x>0 && x<=n && y>0 && y<=m) return true;
    return false;
}
void dfs(int x,int y,int dep)
{
    F[x][y]=dep;
    if (x==ex && y==ey) return ;
    int tx,ty,s;
    for (int i=0;i<=3;i++)
    {
        tx=x+dx[i]; ty=y+dy[i];
        if (check(tx,ty) && map[tx][ty]!='o')
        {
            if (map[tx][ty]=='.') s=1;
            else s=2;
            if (s+dep<F[tx][ty]) dfs(tx,ty,s+dep);
        }
    }
}
int main()
{
    scanf("%d%d%d",&t,&m,&n); getchar();
    for (int i=1;i<=n;i++)
    {
        for (int j=1;j<=m;j++)
        {
            scanf("%c",&map[i][j]);
            if (map[i][j]=='s')
            {
                bx=i; by=j; map[i][j]='.';
            }
            else if (map[i][j]=='m')
            {
                ex=i; ey=j; map[i][j]='.';
            }
        }
        getchar();
    }
    for (int i=1;i<=n;i++)
        for (int j=1;j<=m;j++)
            F[i][j]=1010;
    dfs(bx,by,0);
    int Min=F[ex][ey];
    if (Min>=t) printf("55555\n");
    else printf("%d\n",Min);
    return 0;
}

开拓者 2009-08-29 09:45 发表评论

【DFS 送给圣诞夜的极光】

开拓者 — Fri, 28 Aug 2009 12:36:00 GMT

描述 Description
圣诞老人回到了北极圣诞区，已经快到12点了。也就是说极光表演要开始了。这里的极光不是极地特有的自然极光景象。而是圣诞老人主持的人造极光。
轰隆隆……烟花响起（来自中国的浏阳花炮之乡）。接下来就是极光表演了。
人造极光其实就是空中的一幅幅n*m的点阵图像。只是因为特别明亮而吸引了很多很多小精灵的目光，也成为了圣诞夜最美丽的一刻。
然而在每幅n*m的点阵图像中，每一个点只有发光和不发光两种状态。对于所有的发光的点，在空中就形成了美丽的图画。而这个图画是以若干个（s个）图案组成的。对于图案，圣诞老人有着严格的定义：对于两个发光的点，如果他们的曼哈顿距离（对于A(x1,y1)和B(x2,y2)，A和B之间的曼哈顿距离为|x1-x2|+|y1-y2|）小于等于2。那么这两个点就属于一个图案……
小精灵们一边欣赏着极光，一边数着每一幅极光图像中的图案数。伴着歌声和舞蹈，度过了美丽的圣诞之夜。^_^

输入格式 Input Format
第一行，两个数n和m。
接下来一共n行，每行m个字符。对于第i行第j个字符，如果其为“-”，那么表示该点不发光，如果其为“#”，那么表示该点发光。不可能出现其他的字符。

输出格式 Output Format
第一行，一个数s。

样例输入 Sample Input
19 48
------------------------------------------------
---####-----#-----#----------------------####---
--######----#-----#---------------------######--
-########--#-#---#-#####--#-##-##---#--########-
-###--###--#-#---#-#----#-##-##--#--#--###--###-
-###--###--#--#-#--######-#--#---#-#---###--###-
-########--#--#-#--#------#--#----##---########-
--######---#---#---######-#--#-----#----######--
---####----------------------------#-----####---
----------------------------------#-------------
------------------------------------------------
---###--#--------#------#-----------------------
--#---#-#---------------#-----------------------
-#------#-##--#-##--##-###-#-##-###--###-#--##--
-#------##--#-##-#-#----#--##--#---##---##-#----
-#------#---#-#--#--#---#--#---#---##----#--#---
--#---#-#---#-#--#---#--#--#---#---##---##---#--
---###--#---#-#--#-##---#--#---#---#-###-#-##---
------------------------------------------------

样例输出 Sample Output
4

【参考程序】：

#include<cstring>
#include<cstdio>
#include<cmath>
#include<iostream>
using namespace std;

const int dx[12]={1,-1,0,0,2,-2,0,0,1,-1,1,-1};
const int dy[12]={0,0,1,-1,0,0,2,-2,-1,1,1,-1};
int map[110][110];
int n,m,ans;
bool check(int x,int y)
{
    if (x>0 && x<=n && y>0 && y<=m) return true;
    return false;
}
void dfs(int x,int y)
{
    map[x][y]=0;
    int tx,ty;
    for (int i=0;i<=11;i++)
    {
        tx=x+dx[i]; ty=y+dy[i];
        if (check(tx,ty) && map[tx][ty]==1)
            dfs(tx,ty);
    }
}
int main()
{
    scanf("%d%d",&n,&m); getchar();
    char ch;
    for (int i=1;i<=n;i++)
    {
        for (int j=1;j<=m;j++)
        {
            scanf("%c",&ch);
            if (ch=='-') map[i][j]=0;
            else map[i][j]=1;
        }
        getchar();
    }
    ans=0;
    for (int i=1;i<=n;i++)
        for (int j=1;j<=m;j++)
            if (map[i][j]==1)
            {
                ans++;
                //printf("%d %d\n",i,j);
                dfs(i,j);
            }
    printf("%d\n",ans);
    return 0;
}

开拓者 2009-08-28 20:36 发表评论

【树状数组校门外的树】

开拓者 — Fri, 21 Aug 2009 02:59:00 GMT

描述 Description
校门外有很多树，有苹果树，香蕉树，有会扔石头的，有可以吃掉补充体力的……
如今学校决定在某个时刻在某一段种上一种树，保证任一时刻不会出现两段相同种类的树，现有两个操作：
K=1，读入l,r表示在l~r之间种上的一种树
K=2，读入l,r表示询问l~r之间能见到多少种树(l,r>0)

输入格式 Input Format
第一行n,m表示道路总长为n，共有m个操作
接下来m行为m个操作

输出格式 Output Format
对于每个k=2输出一个答案

样例输入 Sample Input
5 4 1 1 3 2 2 5 1 2 4 2 3 5

样例输出 Sample Output
1 2

注释 Hint
范围：
20%的数据保证，n,m<=100
60%的数据保证，n <=1000,m<=50000
100%的数据保证，n,m<=50000

【参考程序】：//树状数组

#include<cstring>
#include<cstdio>
#include<iostream>
using namespace std;

typedef int array[50010];
array a,b;
int n,m;
int lowbit(int x)
{
    return x^(x&(x-1));
}
void add(int x,array &c)
{
    while (x<=n)
    {
        c[x]++;
        x+=lowbit(x);
    }
}
int getsum(int x,array c)
{
    int sum=0;
    while (x)
    {
        sum+=c[x];
        x-=lowbit(x);
    }
    return sum;
}
int main()
{
    scanf("%d%d",&n,&m);
    memset(a,0,sizeof(a));
    memset(b,0,sizeof(b));
    int t,l,r;
    for (int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&t,&l,&r);
        if (t==1)
        {
            add(l,a); add(r,b);
        }
        else
        {
            int s=getsum(r,a)-getsum(l-1,b);
            printf("%d\n",s);
        }
    }
    return 0;
}

开拓者 2009-08-21 10:59 发表评论

【树状数组笨笨的西瓜种植（赛）】

开拓者 — Tue, 11 Aug 2009 11:58:00 GMT

背景 Background

笨笨：小西瓜，小西瓜~
路人甲：不会呀，这西瓜明明就大着啊……
笨笨：那……大西瓜，大西瓜~
路人甲：这么快就改口了……
笨笨：西瓜西瓜~可爱的西瓜~

描述 Description

笨笨种了一块西瓜地，但这块西瓜地的种植范围是一条直线的……
笨笨在一番研究过后，得出了m个结论，这m个结论可以使他收获的西瓜最多。
笨笨的结论是这样的：
从西瓜地B处到E处至少要种植T个西瓜，这个范围的收获就可以最大化。
笨笨不想那么辛苦，所以他想种植的西瓜尽量少，而又满足每一个所得的结论。

输入格式 Input Format
第一行两个数n,m（0接下来m行表示笨笨的m个结论，每行三个数b,e,t（1<=b<=e<=n,0<=t<=e-b+1）。

输出格式 Output Format
输出笨笨最少需种植多少西瓜。

分析：
qsort+树状数组。

【参考程序】：

#include<cstring>
#include<cstdio>
#include<iostream>
using namespace std;

struct node
{
    int b,e,t;
} a[3010];
int f[5010],c[5010];
int n,m;
int cmp(const void *s,const void *t)
{
    node i=*(node *)s,j=*(node *)t;
    return i.e-j.e;
}
int lowbit(int x)
{
    return x^(x&(x-1));
}
void modify(int x)
{
    while (x<=n)
    {
        c[x]++;
        x+=lowbit(x);
    }
}
int getsum(int x)
{
    int sum=0;
    while (x)
    {
        sum+=c[x];
        x-=lowbit(x);
    }
    return sum;
}
int main()
{
    scanf("%d%d",&n,&m);
    for (int i=1;i<=m;i++)
        scanf("%d%d%d",&a[i].b,&a[i].e,&a[i].t);
    qsort(a+1,m,sizeof(node),cmp);
    memset(c,0,sizeof(c));
    memset(f,0,sizeof(f));
    int need,ans=0;
    for (int i=1;i<=m;i++)
    {
        need=a[i].t-(getsum(a[i].e)-getsum(a[i].b-1));
        for (int j=a[i].e;j>=a[i].b;j--)
        {
            if (need<=0) break;
            if (!f[j])
            {
                f[j]=1; need--;
                modify(j); ans++;
            }
        }
    }
    printf("%d\n",ans);
    return 0;
}

开拓者 2009-08-11 19:58 发表评论

【网络流笨笨的洪水堵截(賽)】

开拓者 — Tue, 11 Aug 2009 03:27:00 GMT

背景 Background
笨笨：汗……
路人甲：大汗……
笨笨：瀑布汗……
路人甲：大瀑布汗……
笨笨：懒得和你汗……
路人甲：怎么这么多水的啊？

描述 Description
一场洪水即将到来，笨笨要想方设法堵截它！
堵截洪水的唯一办法是在洪水经过河流的岔道口放上石头！（笨笨在将小石头一颗一颗地磊好……囧）
对于不同的岔道口，需要的石头量不同，而笨笨所要消耗的体力也不同。
为了不太累，笨笨决定要用最少的体力来堵截这场洪水，洪水从岔道0出发，笨笨要防止洪水冲到岔道n。

输入格式 Input Format
输入有多组，输入第一行为组数（组数小于15）。
每组输入格式如下。
第一行两个数n,m（0第二行n-1个数，第i个数表示堵截该岔道需要消耗笨笨k[i]的体力。(i=1 to n-1，每个k[i]都是正整数)
接下来m行，每行两个数a,b，表示岔道a和岔道b之间有河道连接。

输出格式 Output Format
对于每一组输入一个输出。
每组输入输出一行，表示笨笨所需要消耗的最小体力。
若洪水不可能冲到岔道n，则输出“Min!”，若洪水无法阻止，则输出“Max!”。

样例输入 Sample Input
1
4 5
2 3 4
0 1
0 3
1 2
2 4
3 4

样例输出 Sample Output
6

时间限制 Time Limitation
1s
注释 Hint
对样例的解释：

洪水从0出发。
而笨笨要阻止洪水流到n。
耗体力最少的堵截方式就是将岔道1和岔道3堵上即可。
消耗体力最小总和为2+4=6。

【参考程序】：

#include<cstring>
#include<cstdio>
#define maxint 0x7FFFFFFF
using namespace std;

int g[210][210],queue[210],prev[210];
bool vis[210];
int n,m,ans;
bool bfs_path()
{
    memset(vis,false,sizeof(vis));
    memset(prev,0,sizeof(prev));
    int head,tail,now;
    head=tail=1;
    queue[1]=0; vis[0]=true;
    while (head<=tail)
    {
        now=queue[head];
        for (int i=1;i<=2*n+1;i++)
            if (!vis[i] && g[now][i])
            {
                vis[i]=true;
                tail++;
                queue[tail]=i; prev[i]=now;
                if (i==n) return true;
            }
        head++;
    }
    return false;
}
int main()
{
    int a,b,T,bk;
    scanf("%d",&T);
    for (int t=1;t<=T;t++)
    {
        scanf("%d%d",&n,&m);
        if (n==0)
        {
            printf("Max!\n"); continue;
        }
        memset(g,0,sizeof(g));
        for (int i=1;i<n;i++) scanf("%d",&g[n+1+i][i]);
        bk=1;
        for (int i=1;i<=m;i++)
        {
            scanf("%d%d",&a,&b);
            if ((a==0 && b==n)||(a==n && b==0)) bk=0;
        a    g[a][n+1+b]=g[b][n+1+a]=maxint;
        }
        g[n+1+n][n]=maxint;
        if (!bk)
        {
            printf("Max!\n");continue;
        }
        ans=0;
        while (bfs_path())
        {
            int flow=maxint,i;
            i=n;
            while (i!=0)
            {
                if (flow>g[prev[i]][i]) flow=g[prev[i]][i];
                i=prev[i];
            }
            ans+=flow;
            i=n;
            while (i!=0)
            {
                g[prev[i]][i]-=flow;
                if (g[i][prev[i]]+flow<=maxint)
                    g[i][prev[i]]+=flow;
                else g[i][prev[i]]=maxint;
                i=prev[i];
            }
        }
        if (ans==0) printf("Min!\n");
        else printf("%d\n",ans);
    }
    return 0;
}

开拓者 2009-08-11 11:27 发表评论

【Network of Schools 校园网】

开拓者 — Sun, 09 Aug 2009 03:29:00 GMT

一些学校连入一个电脑网络。那些学校已订立了协议：每个学校都会给其它的一些学校分发软件（称作“接受学校”）。注意如果 B 在 A 学校的分发列表中，那么 A 不一定也在 B 学校的列表中。

你要写一个程序计算，根据协议，为了让网络中所有的学校都用上新软件，必须接受新软件副本的最少学校数目（子任务 A）。更进一步，我们想要确定通过给任意一个学校发送新软件，这个软件就会分发到网络中的所有学校。为了完成这个任务，我们可能必须扩展接收学校列表，使其加入新成员。计算最少需要增加几个扩展，使得不论我们给哪个学校发送新软件，它都会到达其余所有的学校（子任务 B）。一个扩展就是在一个学校的接收学校列表中引入一个新成员。

格式
PROGRAM NAME: schlnet
INPUT FORMAT输入文件的第一行包括一个整数 N：网络中的学校数目（2 <= N <= 100）。学校用前 N 个正整数标识。接下来 N 行中每行都表示一个接收学校列表（分发列表）。第 i+1 行包括学校 i 的接收学校的标识符。每个列表用 0 结束。空列表只用一个 0 表示。

OUTPUT FORMAT
你的程序应该在输出文件中输出两行。第一行应该包括一个正整数：子任务 A 的解。第二行应该包括子任务 B 的解。

SAMPLE INPUT (file schlnet.in)
5
2 4 3 0
4 5 0
0
0
1 0

SAMPLE OUTPUT (file schlnet.out)
1
2

分析：(转byvoid)

这是一道收缩强连通分量的题。

该题描述的是一个有向图。我们都知道，在一个有向图强连通分量中从任意一个顶点开始，可以到达强连通分量的每个顶点。由此可以把该题中所有强连通分量收缩成分别一个顶点，则入度为0的顶点就是最少要接受新软件副本的学校。

第二问就是，问至少添加多少条边，才能使原图强连通。也就问在收缩后的图至少添加多少条边，才能使之强连通。

可以知道，当存在一个顶点入度为0或者出度为0的时候，该图一定不是强连通的。为了使添加的边最少，则应该把入度为0顶点和出度为0的顶点每个顶点添加1条边，使图中不存在入度为0顶点和出度为0的顶点。

当入度为0的顶点多于出度为0的顶点，则应添加的边数应为入度为0的顶点的个数。当出度为0的顶点多于出入度为0的顶点，则应添加的边数应为出度为0的顶点的个数。

这样就可以解决问题了。但是不要忘了还有特殊的情况，当原图本身就是强连通分量时，收缩成一个顶点，该顶点入度和出度都为0，但第一问应为1，第二问应为0。

求强连通分量，我用的两遍深搜的Kosaraju算法，时间复杂度为O(n)。把找到的每个强连通分量收缩为一的顶点，组成新图。设r(x)为x所在的强连同分量的代表节点，如果原图中存在边e(x,y)，那么新图中有边e(r(x),r(y)) 。然后根据点的邻接关系统计出度和入度即可。

【参考程序】：

/*
ID: XIONGNA1
PROG: schlnet
LANG: C++
*/
#include<iostream>
#include<cstring>
using namespace std;

int g1[101][101],g2[101][101];
int into[101],out[101],belong[101];
bool vis[101],dis[101][101];
int n,m,I0,O0;

void g1dfs(int k)
{
    vis[k]=true;
    for (int i=1;i<=g1[k][0];i++)
        if (!vis[g1[k][i]])
            g1dfs(g1[k][i]);
}
void g2dfs(int k)
{
    belong[k]=m;
    for (int i=1;i<=g2[k][0];i++)
        if (vis[g2[k][i]] && !belong[g2[k][i]])
            g2dfs(g2[k][i]);
}
void solve()
{
    memset(vis,false,sizeof(vis));
    memset(belong,0,sizeof(belong));
    m=0;
    for (int i=1;i<=n;i++)
        if (belong[i]==0)
        {
            g1dfs(i);
            m++;
            g2dfs(i);
            memset(vis,false,sizeof(vis));
        }
    memset(dis,false,sizeof(dis));
    for (int i=1;i<=n;i++)
        for (int j=1;j<=g1[i][0];j++)
            dis[belong[i]][belong[g1[i][j]]]=true;
    memset(into,0,sizeof(into));
    memset(out,0,sizeof(out));
    for (int i=1;i<=m;i++)
        for (int j=1;j<=m;j++)
            if (i!=j && dis[i][j])
            {
                into[j]++;
                out[i]++;
            }
    I0=0;O0=0;
    for (int i=1;i<=m;i++)
    {
        if (into[i]==0) I0++;
        if (out[i]==0) O0++;
    }
}
void cout_ans()
{
    if (m==1) printf("1\n0\n");
    else
    {
        printf("%d\n",I0);
        if (I0>O0) printf("%d\n",I0);
        else printf("%d\n",O0);
    }
}
int main()
{
    freopen("schlnet.in","r",stdin);
    freopen("schlnet.out","w",stdout);
    scanf("%d",&n);
    memset(g1,0,sizeof(g1));
    memset(g2,0,sizeof(g2));
    int x;
    for (int i=1;i<=n;i++)
    {
        scanf("%d",&x);
        while (x)
        {
            g1[i][++g1[i][0]]=x;
            g2[x][++g2[x][0]]=i;
            scanf("%d",&x);
        }
    }
    solve();
    cout_ans();
    return 0;
}

开拓者 2009-08-09 11:29 发表评论

【Milk Measuring 量取牛奶】

开拓者 — Sat, 08 Aug 2009 01:16:00 GMT

农夫约翰要量取 Q（1 <= Q <= 20,000）夸脱（夸脱，quarts，容积单位——译者注）他的最好的牛奶，并把它装入一个大瓶子中卖出。消费者要多少，他就给多少，从不有任何误差。

农夫约翰总是很节约。他现在在奶牛五金商店购买一些桶，用来从他的巨大的牛奶池中量出 Q 夸脱的牛奶。每个桶的价格一样。你的任务是计算出一个农夫约翰可以购买的最少的桶的集合，使得能够刚好用这些桶量出 Q 夸脱的牛奶。另外，由于农夫约翰必须把这些桶搬回家，对于给出的两个极小桶集合，他会选择“更小的”一个，即：把这两个集合按升序排序，比较第一个桶，选择第一个桶容积较小的一个。如果第一个桶相同，比较第二个桶，也按上面的方法选择。否则继续这样的工作，直到相比较的两个桶不一致为止。例如，集合 {3，5，7，100} 比集合 {3，6，7，8} 要好。

为了量出牛奶，农夫约翰可以从牛奶池把桶装满，然后倒进瓶子。他决不把瓶子里的牛奶倒出来或者把桶里的牛奶倒到别处。用一个容积为 1 夸脱的桶，农夫约翰可以只用这个桶量出所有可能的夸脱数。其它的桶的组合没有这么方便。

计算需要购买的最佳桶集，保证所有的测试数据都至少有一个解。

格式
PROGRAM NAME: milk4
INPUT FORMAT
Line 1: 一个整数 Q

Line 2: 一个整数P（1 <= P <= 100），表示商店里桶的数量

Lines 3..P+2: 每行包括一个桶的容积（1 <= 桶的容积 <= 10000）

OUTPUT FORMAT
输出文件只有一行，由空格分开的整数组成：

为了量出想要的夸脱数，需要购买的最少的桶的数量，接着是：

一个排好序的列表（从小到大），表示需要购买的每个桶的容积

SAMPLE INPUT (file milk4.in)
16
3
3
5
7

SAMPLE OUTPUT (file milk4.out)
2 3 5

分析：
此题用的是DFSID的解法，对于每次DFSID我们都找出组合为1个桶，2个，3个.....P个，每次用前面选的一层层的叠上去，对于每次找出的组合我们都去Judge，再用一个完全背包(原话：每个桶至少用一次)来判断每次组合是否完成Q的量取,answer就是达到Q那组----因为在读入数据时我就加了一个从小到大的快排，所以DFS出来的顺序已经是达到了题目要求，所以直接输出即可。

    背包的状态方程：bo[j]=bo[j] or bo[j-v[used[i]]](1<=i<=V,v[used[i]]<=j<=Q)
                   used[i]:第i个桶的容积。
    初始化：bo全部都是false，bo[0]=true

此处的背包循环了很多没有用到的冗余次数，如果不加优化有一组过不了，所以背包有一些优化。
优化：对于每次的组合都有i=1......Q/v[used[1]],则bo[i*v[used[1]]]=true,其它的状态都可以有前面的推出。

【参考程序】：

/*
ID: XIONGNA1
PROG: milk4
LANG: C++
*/
#include<iostream>
#include<cstring>
using namespace std;
int V[101],Used[101];
bool bo[20001];
int P,Q,k;
int cmp(const void *s,const void *t)
{
    int i=*(int *)s,j=*(int *)t;
    return i-j;
}
void cout_ans()
{
    printf("%d",k);
    for (int i=1;i<=k;i++) printf(" %d",V[Used[i]]);
    printf("\n");
    exit(0);
}
void Judge()
{
    memset(bo,false,sizeof(bo));
    bo[0]=true;
    for (int i=1;i<=Q/V[Used[1]];i++)
        bo[i*V[Used[1]]]=true;
    for (int i=1;i<=k;i++)
        for (int j=V[Used[i]];j<=Q;j++)
            bo[j]=bo[j] || bo[j-V[Used[i]]];
    if (bo[Q]) cout_ans();
}
void dfs(int dep)
{
    for (int i=Used[dep-1]+1;i<=P-k+dep;i++)
    {
        Used[dep]=i;
        if (dep==k) Judge();
        else dfs(dep+1);
    }
}
void dfsid()
{
    for (k=1;k<=P;k++) dfs(1);
}
int main()
{
    freopen("milk4.in","r",stdin);
    freopen("milk4.out","w",stdout);
    scanf("%d%d",&Q,&P);
    for (int i=1;i<=P;i++) scanf("%d",&V[i]);
    qsort(V+1,P,sizeof(V[1]),cmp);
    memset(Used,0,sizeof(Used));
    dfsid();
    return 0;
}

开拓者 2009-08-08 09:16 发表评论

【Wisconsin Squares 威斯康星州的牧场】

开拓者 — Fri, 07 Aug 2009 12:43:00 GMT

威斯康星州的春天来了，是该把小奶牛们赶到小牧场上并把大奶牛们赶到北纬 40 度的大牧场上的时候了。

农夫约翰的牧场上有五种奶牛（括号内的是缩写）：格恩西奶牛（A），泽西奶牛（B），赫里福奶牛（C），黑安格斯奶牛（D），朗赫恩奶牛（E）。这些奶牛群放养在一片 16 英亩的牧场上，每英亩上都有一小群奶牛，像下面这样排列成 4 x 4 的格子（用行和列标号）：

1 2 3 4
+-------
1|A B A C
2|D C D E
3|B E B C
4|C A D E

最初，牧场上的奶牛群总共有 3 群 A，3 群 B，4 群 C，3 群 D，3 群 E。今年的 D 种小奶牛比去年多一群，C 种少一群，共有 3 群 A，3 群 B，3 群 C，4 群 D，3 群 E。

农夫约翰对于他牧场上的奶牛群的布局非常小心。这是因为如果同一种类型的奶牛群靠得太近，她们就乱来：她们聚集在栅栏边上抽烟，喝牛奶。如果她们在相同的格子上或者在临近的 8 个格子上，就是靠得太近了。

农夫约翰得用他的棕色旧福特皮卡把他的大奶牛群运出牧场，并把他的小奶牛群运进牧场，皮卡一次只能运一群奶牛。他装上一群小奶牛，开车到小牧场的一个方格中，卸下这群小奶牛，再装上这个格子上的那群大奶牛，开到北纬 40 度的大牧场卸下来。他重复这样的操作 16 次，然后开车去杰克商店办理低脂酸奶的交易和家居装修。

帮助农夫约翰。他必须选择正确的顺序来替换他的奶牛群，使得他从不把一群小奶牛放入当前被同样类型奶牛占有的方格或者当前被同样类型奶牛占据的方格的临近方格。当然，一旦大奶牛走了，小奶牛就被安置好（in place），他必须小心以后的情况，要根据新的排列把奶牛群分开。

非常重要的提示：农夫约翰从过去的经验知道，他必须先移动 D 种奶牛群。

找出农夫约翰将他的小奶牛搬迁到她们的新牧场上的办法。输出 16 个连续的奶牛群类型/行/列的信息，使得这样的安排能够符合安全经验。

计算 4 x 4 牧场的最终排列总数和产生那些排列的方式的总数。

格式
PROGRAM NAME: wissqu
INPUT FORMAT
四行，每行四个字母，表示奶牛群。

OUTPUT FORMAT
16 行，每行分别由奶牛群类型/行/列组成。如果有多解（一定有），那么你应该输出奶牛群类型按照字典序排列在最前面的那个解。如果不只一个解满足条件，那么你应该输出行信息按照字典需排列在最前面的那个解。如果仍然不只一个解满足条件，那么你应该输出列信息按照字典序排列在最前面的那个解。

最后多输出一行，包含能够由这个排列方式产生的排列的总数。

SAMPLE INPUT (file wissqu.in)
ABAC
DCDE
BEBC
CADE

SAMPLE OUTPUT (file wissqu.out)
D 4 1
C 4 2
A 3 1
A 3 3
B 2 4
B 3 2
B 4 4
E 2 1
E 2 3
D 1 4
D 2 2
C 1 1
C 1 3
A 1 2
E 4 3
D 3 4
14925

【参考程序】：

/*
ID: XIONGNA1
PROG: wissqu
LANG: C++
*/
#include<iostream>
#include<cstring>
using namespace std;

const int dx[9]={0,1,0,-1,-1,-1,0,1,1};
const int dy[9]={0,1,1,1,0,-1,-1,-1,0};

char ans1[17],a[6][6];
int f[6][6][6],ans2[17],ans3[17],rest[6];
bool done[6][6];
int ans;
void come(int x,int y,char c)
{
    for (int i=0;i<=8;i++)
        f[x+dx[i]][y+dy[i]][c-64]++;
}
void go(int x,int y,char c)
{
    for (int i=0;i<=8;i++)
        f[x+dx[i]][y+dy[i]][c-64]--;
}
void Search(int x,int y,int c,int dep)
{
    ans1[dep]=c; ans2[dep]=x; ans3[dep]=y;
    if (dep==16)
    {
        ans++;
        if (ans==1)
            for (int i=1;i<=16;i++)
                printf("%c %d %d\n",char(ans1[i]+64),ans2[i],ans3[i]);
        return ;
    }
    go(x,y,a[x][y]);
    come(x,y,char(c+64));
    done[x][y]=true;
    for (int k=1;k<=5;k++)
        if (rest[k])
            for (int i=1;i<=4;i++)
                for (int j=1;j<=4;j++)
                    if (f[i][j][k]==0 && !done[i][j])
                    {
                        rest[k]--;
                        Search(i,j,k,dep+1);
                        rest[k]++;
                    }
    come(x,y,a[x][y]);
    go(x,y,char(c+64));
    done[x][y]=false;
}
int main()
{
    freopen("wissqu.in","r",stdin);
    freopen("wissqu.out","w",stdout);
    memset(f,0,sizeof(f));
    for (int i=1;i<=4;i++)
    {
        for (int j=1;j<=4;j++)
        {
            scanf("%c",&a[i][j]);
            come(i,j,a[i][j]);
        }
        getchar();
    }
    memset(done,false,sizeof(done));
    ans=0;
    for (int i=1;i<=5;i++) rest[i]=3;
    for (int i=1;i<=4;i++)
        for (int j=1;j<=4;j++)
            if (f[i][j][4]==0)
                Search(i,j,4,1);
    printf("%d\n",ans);
    return 0;
}

开拓者 2009-08-07 20:43 发表评论

【Snail Trails 蜗牛的旅行】

开拓者 — Thu, 06 Aug 2009 05:37:00 GMT

丽·斯内尔（Sally Snail，蜗牛）喜欢在 N x N 的棋盘上闲逛（1 < n <= 120）。她总是从棋盘的左上角出发。棋盘上有空的格子（用“.”来表示）和 B 个路障（用“#”来表示）。下面是这种表示法的示例棋盘：

A B C D E F G H
1 S . . . . . # .
2 . . . . # . . .
3 . . . . . . . .
4 . . . . . . . .
5 . . . . . # . .
6 # . . . . . . .
7 . . . . . . . .
8 . . . . . . . .

萨丽总是垂直（向上或者向下）或水平（向左或者向右）地走。她可以从出发地（总是记作 A1 ）向下或者向右走。一旦萨丽选定了一个方向，她就会一直走下去。如果她遇到棋盘边缘或者路障，她就停下来，并且转过 90 度。她不可能离开棋盘，或者走进路障当中。并且，萨丽从不跨过她已经经过的格子。当她再也不能走的时候，她就停止散步。

这里是上面的棋盘上的一次散步路线图示：

A B C D E F G H
1 S---------+ # .
2 . . . . # | . .
3 . . . . . | . .
4 . . . . . +---+
5 . . . . . # . |
6 # . . . . . . |
7 +-----------+ |
8 +-------------+

萨丽向右走，再向下，向右，向下，然后向左，再向上，最后向右走。这时她遇到了一个她已经走过的格子，她就停下来了。但是，如果她在 F5 格遇到路障后选择另外一条路——向我们看来是左边的方向转弯，情况就不一样了。

你的任务是计算并输出，如果萨丽聪明地选择她的路线的话，她所能够经过的最多格子数。

格式
PROGRAM NAME: snail
INPUT FORMAT
输入的第一行包括 N ——棋盘的大小，和 B ——路障的数量（1 <= B <= 200）。接下来的 B 行包含着路障的位置信息。下面的样例输入对应着上面的示例棋盘。下面的输出文件表示问题的解答。注意，当 N 〉26 时，输入文件就不能表示 Z 列以后的路障了。

OUTPUT FORMAT
输出文件应该只由一行组成，即萨丽能够经过的最多格子数。

SAMPLE INPUT (file snail.in)
8 4
E2
A6
G1
F5

SAMPLE OUTPUT (file snail.out)
33

样例说明

A B C D E F G H
1 S . . . . . # .
2 | . . . # . . .
3 | . . . +-----+
4 | . . . | . . |
5 +-------+ # . |
6 # . . . . . . |
7 +------------ |
8 +-------------+

【参考程序】：

/*
ID: XIONGNA1
PROG: snail
LANG: C++
*/
#include<iostream>
#include<cstring>
using namespace std;
const int dx[4]={0,1,0,-1};
const int dy[4]={1,0,-1,0};
int a[130][130];
int n,b,ans;
void dfs(int x,int y,int d,int dep)
{
    int xx,yy,deps;
    xx=x; yy=y; deps=dep;
    while (a[xx+dx[d]][yy+dy[d]]==0)
    {
        xx+=dx[d]; yy+=dy[d];
        a[xx][yy]=-1;
        deps++;
    }
    if (xx==x && yy==y) return ;
    if (deps>ans) ans=deps;
    if (a[xx+dx[d]][yy+dy[d]]==1)
    {
        dfs(xx,yy,(d+1)%4,deps);
        dfs(xx,yy,(d+3)%4,deps);
    }
    while (xx!=x || yy!=y)
    {
        a[xx][yy]=0;
        xx-=dx[d]; yy-=dy[d];
    }
}
int main()
{
    freopen("snail.in","r",stdin);
    freopen("snail.out","w",stdout);
    scanf("%d%d",&n,&b);getchar();
    memset(a,0,sizeof(a));
    for (int i=0;i<=n+1;i++)
    {
        a[0][i]=a[n+1][i]=1;
        a[i][0]=a[i][n+1]=1;
    }
    char c; int j;
    for (int i=1;i<=b;i++)
    {
        scanf("%c%d",&c,&j);
        a[j][c-64]=1;
        getchar();
    }
    ans=0; a[1][1]=-1;
    dfs(1,1,0,1);
    dfs(1,1,1,1);
    printf("%d\n",ans);
    return 0;
}

开拓者 2009-08-06 13:37 发表评论

【Pascal 山脉】

开拓者 — Tue, 04 Aug 2009 08:31:00 GMT

描述
小卡卡顺着老者所指的方向，来到了Pascal神峰的顶峰。老者告诉小卡卡，Pascal山脉有很多座山，都排在一条直线上，每座山都有不同的高度。
Pascal山的山顶有一个神奇的洞穴，进入这个洞穴后，你将会到达这座山前方的另一座山,更加神奇的是，你到达的山一定比他所在的山高度要小。而Pascal圣地最大的宝藏就藏在某一座Pascal山上的洞穴中，这个洞穴的特点是它有一道石门封闭着。
小卡卡很想知道进入每座山的洞穴后，他所到达的不同的山会有多少种可能。

输入
该题含有多组测试数据。
第一行一个整数n,表示山的个数.(1<=n<=200000)
第二行以后n行从前到后给出每座山的高度。另外两座山可以有相同的高度.(1<=每座山的高度<=maxlongint)

输出
共n行,每行一个整数.第I行的整数表示他进入第I号山的洞穴后能够到达的不同的山的个数.

样例输入
5
1
2
3
4
5

样例输出
0
1
2
3
4

分析：离散化+树状数组

【参考程序】：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
struct node
{
    int x,y;
} a[200001];
int b[200001],c[200001];
int n,len;
int cmp(const void *s,const void *t)
{
    node i=*(node *)s,j=*(node *)t;
    return i.x-j.x;
}
int lowbit(int x)
{
    return x^(x&(x-1));
}
void modify(int x)
{
    while (x<=len)
    {
        c[x]++;
        x+=lowbit(x);
    }
}
int getsum(int x)
{
    int s=0;
    while (x)
    {
        s+=c[x];
        x-=lowbit(x);
    }
    return s;
}
int main()
{
    //freopen("a1.in","r",stdin);
    //freopen("a1.out","w",stdout);
    while (scanf("%d",&n)!=EOF)
    {
        for (int i=1;i<=n;i++)
        {
            scanf("%d",&a[i].x);
            a[i].y=i;
        }
        qsort(a+1,n,sizeof(node),cmp);
        a[0].x=-1;
        len=0;
        for (int i=1;i<=n;i++)
        {
            if (a[i].x!=a[i-1].x) len++;
            b[a[i].y]=len;
        }
        memset(c,0,sizeof(c));
        for (int i=1;i<=n;i++)
        {
            int sum=getsum(b[i]-1);
            printf("%d\n",sum);
            modify(b[i]);
        }
    }
    return 0;
}

开拓者 2009-08-04 16:31 发表评论

【Shuttle Puzzle 棋盘游戏】

开拓者 — Thu, 30 Jul 2009 09:08:00 GMT

摘要: 大小为3的棋盘游戏里有3个白色棋子，3个黑色棋子，和一个有7个格子一线排开的木盒子。3个白棋子被放在一头，3个黑棋子被放在另一头，中间的格子空着。初始状态: WWW_BBB 目标状态: BBB_WWW 在这个游戏里有两种移动方法是允许的： 1. 你可以把一个棋子移到与它相邻的空格； 2. 你可以把一个棋子跳过一个(仅一个)与它不同色的棋子到... 阅读全文

开拓者 2009-07-30 17:08 发表评论

【Checker Challenge 跳棋的挑战】

开拓者 — Fri, 17 Jul 2009 01:25:00 GMT

检查一个如下的6 x 6的跳棋棋盘，有六个棋子被放置在棋盘上，使得每行、每列只有一个，每条对角线(包括两条主对角线的所有平行线)上至多有一个棋子。
列号

1　 2　 3　 4　 5　 6

　-------------------------

1 |　 | O |　 |　 |　 |　 |

　-------------------------

2 |　 |　 |　 | O |　 |　 |

　-------------------------

3 |　 |　 |　 |　 |　 | O |

　-------------------------

4 | O |　 |　 |　 |　 |　 |

　-------------------------

5 |　 |　 | O |　 |　 |　 |

　-------------------------

6 |　 |　 |　 |　 | O |　 |

　-------------------------

上面的布局可以用序列2 4 6 1 3 5来描述，第i个数字表示在第i行的相应位置有一个棋子，如下：
行号 1 2 3 4 5 6
列号 2 4 6 1 3 5

这只是跳棋放置的一个解。请编一个程序找出所有跳棋放置的解。并把它们以上面的序列方法输出。解按字典顺序排列。请输出前3个解。最后一行是解的总个数。

特别注意: 对于更大的N(棋盘大小N x N)你的程序应当改进得更有效。不要事先计算出所有解然后只输出(或是找到一个关于它的公式），这是作弊。如果你坚持作弊，那么你登陆USACO Training的帐号将被无警告删除

PROGRAM NAME: checker

INPUT FORMAT:

(checker.in)

一个数字N (6 <= N <= 13) 表示棋盘是N x N大小的。

OUTPUT FORMAT:

(checker.out)

前三行为前三个解，每个解的两个数字之间用一个空格隔开。第四行只有一个数字，表示解的总数。

input：
6

output：
2 4 6 1 3 5
3 6 2 5 1 4
4 1 5 2 6 3
4

【参考程序】：

/*
ID: XIONGNA1
PROG: checker
LANG: C++
*/
#include<iostream>
#include<cstring>
using namespace std;
bool c[31],l[41],r[31];
int n,ans,temp[14];
void dfs(int x)
{
    for (int y=1;y<=n;y++)
        if (c[y+13] && l[y+x+13] && r[y-x+13])
        {
            temp[x]=y;
            c[y+13]=false;l[y+x+13]=false;r[y-x+13]=false;
            if (x<n) dfs(x+1);
            else
            {
                if (ans<3)
                {
                    for (int i=1;i<=n-1;i++) printf("%d ",temp[i]);
                    printf("%d\n",temp[n]);
                }
                ans++;
                if (ans>14244)
                {
                    ans+=59467;return ;
                }
            }
            c[y+13]=true;l[y+x+13]=true;r[y-x+13]=true;
        }
}
int main()
{
    freopen("checker.in","r",stdin);
    freopen("checker.out","w",stdout);
    scanf("%d",&n);
    memset(c,true,sizeof(c));
    memset(l,true,sizeof(l));
    memset(r,true,sizeof(r));
    ans=0;   dfs(1);
    printf("%d\n",ans);
    return 0;
}

【参考程序】：//位运算 by Matrix67

var n,ans,m:longint;
procedure dfs(row,ld,rd:longint);
var pos,p:longint;
begin
    if row<>m then
        begin
            pos:=m and not (row or ld or rd);
            while pos<>0 do
                begin
                     p:=pos and -pos;
                     pos:=pos-p;
                     dfs(row+p,(ld+p)shl 1,(rd+p)shr 1);
                end;
        end
        else inc(ans);
end;
begin
        assign(input,'checker.in');reset(input);
        assign(output,'checker.out');rewrite(output);
   //while not eof do
        begin
            readln(n);
            m:=(1 shl n)-1;
            ans:=0;
            dfs(0,0,0);
            writeln(ans);
    //end;
        close(input);close(output);
end.

开拓者 2009-07-17 09:25 发表评论

【rq 大地的秘密】

开拓者 — Sun, 03 May 2009 12:36:00 GMT

题目叙述
现在他们位于神秘森林的核心部位，面前有两条主要的大道，不用说，一条通向光明，一条通向黑暗。大家当然想奔向光明，远离黑暗，可是蓬絮研究了半个时辰也研究不出个所以然。

倒是细心的花楹发现了线索，她在地上搜寻时，发现了遗落在草丛里的一张纸，纸上如是写道：

致想要寻找出口的人们：
　　这里必须你们真正了解大地的运行规律，才能破解难关。
　　现在，你们只需要拿这这张纸，大喊一声：“哇呱呱呱呱呱呱呱呱呱呱~”，你们前方的地面上就会出现很多的木偶士兵，他们外貌各异。你们必须把他们排布成东边一棵松树上刻纹中写出的阵列，正确的出口才会显露出来。
　　正确的答案就在你们面前，只看你们能不能把握咯。

　　　　　　——米不亚亚亚亚尔之主：巴罗罗罗罗列吉

没办法，虽然这张破破烂烂发着臭气的纸看上去不像真的，死马当作活马医，三人还是照做了。没想到咒语刚说完，前方“嗡～”的一声起了巨大的烟雾。等到烟消云散，三兽定睛一看，地上果然出现了数不清的人偶。

他们开始相信这一张纸的真实性了，动作快的勇气赶忙找到附近的一棵松树。果然，上面也刻着数不请的人偶图案。

现在的任务就是如何调整木偶的顺序了。整个木偶群可以看成一列排布的，所有的 n 个木偶不尽相同，编号为 1-n。由于仙兽功力有限，每次施法只能把一个木偶移动到另两个木偶之间（可以移到队头和队尾）。

经过三个时辰的仔细研究，勇气已经把所有的木偶都正确编号完毕（勇气：累死俺也～她们两个都不干事的……）。现在他需要你告诉他，要完成调整最少需要移动多少次木偶，这样来给他个心里准备……

数据范围
对于 60% 的数据，n <= 1000
对于 100% 的数据，n <= 100000

input：
三行，第一行一个整数 n，表示有 n 个木偶。
第二行，n 个整数（1-n），表示初始时木偶的排布。
第三行，n 个整数（1-n），表示目标木偶的排布

output：
一行，一个整数，表示最少移动次数。
样例解释
先把 1 移动到 10 后面，后面 2-9 每个数移动到 10 和 1 中合适的位置，则 10 不需要移动，共移动 9 次

input：
10
1 2 3 4 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1

output：
9

分析：
此题有两个方法：
   1：求两个序列的最长公共子序列。两个的最长公共子序列，一看似乎没有什么关系，而更多的是想到排序什么的(本人菜一开始也是如此),但是仔细一想有些窍门。
   原理：两个序列，他们都是1--N的元素组成的，而且对于每个序列都包含了对方的那个序列的元素，那么我们可以假设对于两个序列是否存在一些公共（即一样顺序）顺序的元素是我们不需去调换的，想到这，算法不禁的已经出现在眼前：就是求去两个序列的最长公共子序列，最后用总数减去那些不需调换（即最长公共子序列的个数）的个数，就是答案了。
   注意：数据是60%的1000，100%的100000，所以你只能那60分，小数据用此方法，100000用下面的。

   2：求最长的不降子序列。最长的不降子序列，几乎没有表面现象什么可以看出是此算法。
   原理：仔细想一下，如果我们把第一个序列按1 2 3 4 5.......N这样顺序的编号，然后再把第二序列的数值在第一个标号的序列里所对应的标号对应的写入序列中，不要改变位置。
例如：     序列1：    1 2 3 4 5                                  序列2：5  3 1 2 4
                 下标：      1 2 3 4 5             对应序列1的下标：5 3  1  2 4
那么，现在再看一次序列2的下标，它的值所对应的序列1的下标就组成了一个以序列1的先后出现顺序的一个序列，那么我们把这些出现的先后找到一个最长的上升子序列，不就是序列1中所不用调换的最大个数吗？其它的则是需要调换的啦.这样此题就完美解决啦。

【参考程序】：

#include<iostream>
using namespace std;
int a[100001],b[100001];
int c[100001];
int n,size;
int bsearch(int ai)
{
    int l=1,r=size,mid;
    while (l<=r)
    {
        mid=(l+r)>>1;
        if (c[mid-1]<=ai && ai<c[mid]) return mid;
        else if (ai>c[mid]) l=mid+1;
        else r=mid-1;
    }
}
int main()
{
    scanf("%d",&n);
    for (int i=1;i<=n;i++)
    {
        scanf("%d",&b[i]);
        c[b[i]]=i;
    }
    int k;
    for (int i=1;i<=n;i++)
    {
        scanf("%d",&k);
        a[i]=c[k];
    }
    c[1]=a[1];size=1;
    for (int i=2;i<=n;i++)
    {
        int j;
        if (a[i]<=c[1]) j=1;
        else if (a[i]>c[size]) j=++size;
        else j=bsearch(a[i]);
        c[j]=a[i];
    }
    printf("%d\n",n-size);
    return 0;
}

开拓者 2009-05-03 20:36 发表评论

【线段树之数列操作】

开拓者 — Mon, 27 Apr 2009 11:25:00 GMT

【问题描述】

假设有一列数 {A_i }(1 ≤ i ≤ n) ，支持如下两种操作：

(1)将 A_k的值加 D 。（ k, D 是输入的数）

(2) 输出 A_s +A_s+1 +…+A_t 。（ s, t 都是输入的数， S ≤ T ）

根据操作要求进行正确操作并输出结果。

【输入格式】

输入文件第一行一个整数 n(0<=n<=100000) ，第二行为 n 个整数，表示 {A_i } 的初始值。

第三行为一个整数 m(0<=m<=150000) ，表示操作数 v 下接 m 行，每行描述一个操作，有如下两种情况：

ADD k d ( 表示将 A_k加 d ， 1<=k<=n ， d 为整数 )

SUM s t （表示输出 A_s +…+A_t ）

【输出格式】

对于每一个 SUM 提问，输出结果

【输入输出样例】

输入:

4
1 4 2 3
3
SUM 1 3
ADD 2 50
SUM 2 3

输出:

7
56

分析：不用多说什么，就是线段树或者树状数组，我选定的是线段树，思路和我发表的上一篇【I HATE IT】是一样的。

【参考程序】：

#include<iostream>
#include<stdio.h>
using namespace std;
const int maxn=100010;
struct node
{
        int a,b,sum;
        int lc,rc;
} tree[maxn*2];
int a[maxn];
int tail,n,m,Sum;
void modify(int now,int left,int right,int st)
{
        int a1=tree[now].a,b1=tree[now].b;
        if (left==a1 && b1==right)
        {
                tree[now].sum=tree[now].sum+st;
                return ;
        }
        int lcl=tree[now].lc,rcl=tree[now].rc;
        int mid=(a1+b1)>>1;
        if (right<=mid)
        {
                modify(lcl,left,right,st);
                tree[now].sum=tree[tree[now].lc].sum+tree[tree[now].rc].sum;
        }
        else if (left>=mid)
        {
                modify(rcl,left,right,st);
                tree[now].sum=tree[tree[now].lc].sum+tree[tree[now].rc].sum;
        }
        else
        {
                modify(lcl,left,mid,st);
                modify(rcl,mid,right,st);
                tree[now].sum=tree[tree[now].lc].sum+tree[tree[now].rc].sum;
        }
}
void getsum(int now,int left,int right)
{
        int a1=tree[now].a,b1=tree[now].b;
        if (left==a1 && b1==right)
        {
                Sum+=tree[now].sum;
                return ;
        }
        int lcl=tree[now].lc,rcl=tree[now].rc;
        int mid=(a1+b1)>>1;
        if (right<=mid) getsum(lcl,left,right);
        else if (left>=mid) getsum(rcl,left,right);
        else
        {
                getsum(lcl,left,mid);
                getsum(rcl,mid,right);
        }
}
void make_tree(int a1,int b1)
{
        tail++;int now=tail;
        tree[now].a=a1;tree[now].b=b1;
        tree[now].sum=0;
        tree[now].lc=tree[now].rc=-1;
        if (a1+1<b1)
        {
                int mid=(a1+b1)>>1;
                tree[now].lc=tail+1;  make_tree(a1,mid);
                tree[now].rc=tail+1;  make_tree(mid,b1);
                tree[now].sum=tree[tree[now].lc].sum+tree[tree[now].rc].sum;
        }
        else if (a1+1==b1) tree[now].sum=a[b1];
}
int main()
{
        freopen("shulie.in","r",stdin);
        freopen("shulie.out","w",stdout);
        scanf("%d",&n);
        for (int i=1;i<=n;i++) scanf("%d",&a[i]);
  tail=0;
        make_tree(0,n);
        scanf("%d",&m);
        char ss[10]={0};int s,t;
        for (int i=1;i<=m;i++)
        {
                getchar();
                scanf("%s %d%d",ss,&s,&t);
                if (!strcmp(ss,"SUM"))
                {
                        Sum=0;
                        getsum(1,s-1,t);
                        printf("%d\n",Sum);
                }
                else modify(1,s-1,s,t);
        }
        return 0;
}

开拓者 2009-04-27 19:25 发表评论

【HDU I Hate It】

开拓者 — Mon, 27 Apr 2009 03:19:00 GMT

很多学校流行一种比较的习惯。老师们很喜欢询问，从某某到某某当中，分数最高的是多少。
这让很多学生很反感。

不管你喜不喜欢，现在需要你做的是，就是按照老师的要求，写一个程序，模拟老师的询问。当然，老师有时候需要更新某位同学的成绩

input:
本题目包含多组测试，请处理到文件结束。
在每个测试的第一行，有两个正整数 N 和 M ( 0学生ID编号分别从1编到N。
第二行包含N个整数，代表这N个学生的初始成绩，其中第i个数代表ID为i的学生的成绩。
接下来有M行。每一行有一个字符 C (只取'Q'或'U') ，和两个正整数A，B。
当C为'Q'的时候，表示这是一条询问操作，它询问ID从A到B(包括A,B)的学生当中，成绩最高的是多少。
当C为'U'的时候，表示这是一条更新操作，要求把ID为A的学生的成绩更改为B

output:
对于每一次询问操作，在一行里面输出最高成绩

input:
5 6
1 2 3 4 5
Q 1 5
U 3 6
Q 3 4
Q 4 5
U 2 9
Q 1 5

output：
5
6
5
9

【参考程序】：

#include<iostream>
using namespace std;
const int maxn=200010;
struct node
{
        int a,b,score;
        int lc,rc;
} tree[maxn*3];
int a[maxn];
int tail,n,m,MAX;
inline int max(int a,int b)
{
        return a>b?a:b;
}
void modify(int now,int left,int right,int s)
{
        int a1=tree[now].a,b1=tree[now].b;
        if (left==a1 && b1==right)
        {
                tree[now].score=s;
                return ;
        }
        int lcl=tree[now].lc,rcl=tree[now].rc;
        int mid=(a1+b1)>>1;
        if (right<=mid)
        {
                modify(lcl,left,right,s);
                tree[now].score=max(tree[now].score,tree[lcl].score);
        }
        else if (left>=mid)
        {
                modify(rcl,left,right,s);
                tree[now].score=max(tree[now].score,tree[rcl].score);
        }
        else
        {
                modify(lcl,left,mid,s);
                modify(rcl,mid,right,s);
                tree[now].score=max(tree[lcl].score,tree[rcl].score);
        }
}
void getmax(int now,int left,int right)
{
        int a1=tree[now].a,b1=tree[now].b;
        if (left==a1 && b1==right)
        {
                MAX=max(MAX,tree[now].score);
                return ;
        }
        int lcl=tree[now].lc,rcl=tree[now].rc;
        int mid=(a1+b1)>>1;
        if (right<=mid) getmax(lcl,left,right);
        else if (left>=mid) getmax(rcl,left,right);
        else
        {
                getmax(lcl,left,mid);
                getmax(rcl,mid,right);
        }
}
void make_tree(int a1,int b1)
{
        tail++;int now=tail;
        tree[now].a=a1;tree[now].b=b1;
        tree[now].score=-1;
        if (a1+1<b1)
        {
           int mid=(a1+b1)>>1;
           tree[now].lc=tail+1;  make_tree(a1,mid);
           tree[now].rc=tail+1;  make_tree(mid,b1);
           tree[now].score=max(tree[tree[now].lc].score,tree[tree[now].rc].score);
        }
        else if (a1+1==b1) tree[now].score=a[b1];
}
int main()
{
        while (scanf("%d%d",&n,&m)!=EOF)
        {
                for (int i=1;i<=n;i++) scanf("%d",&a[i]);
                tail=0;
                make_tree(0,n);
                int A,B;char c;
                for (int i=1;i<=m;i++)
                {
                        getchar();
                        scanf("%c %d%d",&c,&A,&B);
                        if (c=='Q')
                        {
                                MAX=-0xFFFFFFF;
                                getmax(1,A-1,B);
                                printf("%d\n",MAX);
                        }
                        else modify(1,A-1,A,B);
                }
        }
        return 0;
}

开拓者 2009-04-27 11:19 发表评论

【NlogN的最长不降子序列算法】

开拓者 — Sat, 18 Apr 2009 09:26:00 GMT

看此之前请去做一下此题：
http://www.rqnoj.cn/Problem_Show.asp?PID=167

【转载】：
这是一个很好的题目。题目的算法还是比较容易看出来的，就是求最长上升子序列的长度。不过这一题的数据规模最大可以达到40000，经典的O(n^2)的动态规划算法明显会超时。我们需要寻找更好的方法来解决是最长上升子序列问题。

先回顾经典的O(n^2)的动态规划算法：
设A[i]表示序列中的第i个数，F[i]表示从1到i这一段中以i结尾的最长上升子序列的长度，初始时设F[i] = 0(i = 1, 2, ..., len(A))。则有动态规划方程：F[i] = max{1, F[j] + 1} (j = 1, 2, ..., i - 1, 且A[j] < A[i])。

现在，我们仔细考虑计算F[i]时的情况。假设有两个元素A[x]和A[y]，满足

(1)x < y < I (2)A[x] < A[y] < A[i] (3)F[x] = F[y]

此时，选择F[x]和选择F[y]都可以得到同样的F[i]值，那么，在最长上升子序列的这个位置中，应该选择A[x]还是应该选择A[y]呢？

很明显，选择A[x]比选择A[y]要好。因为由于条件(2)，在A[x+1] ... A[i-1]这一段中，如果存在A[z]，A[x] < A[z] < a[y]，则与选择A[y]相比，将会得到更长的上升子序列。

再根据条件(3)，我们会得到一个启示：根据F[]的值进行分类。对于F[]的每一个取值k，我们只需要保留满足F[i] = k的所有A[i]中的最小值。设D[k]记录这个值，即D[k] = min{A[i]} (F[i] = k)。

注意到D[]的两个特点：

(1) D[k]的值是在整个计算过程中是单调不上升的。
(2) D[]的值是有序的，即D[1] < D[2] < D[3] < ... < D[n]。

利用D[]，我们可以得到另外一种计算最长上升子序列长度的方法。设当前已经求出的最长上升子序列长度为len。先判断A[i]与D[len]。若A[i] > D[len]，则将A[i]接在D[len]后将得到一个更长的上升子序列，len = len + 1， D[len] = A[i]；否则，在D[1]..D[len]中，找到最大的j，满足D[j] < A[i]。令k = j + 1，则有D[j] < A[i] <= D[k]，将A[i]接在D[j]后将得到一个更长的上升子序列，同时更新D[k] = A[i]。最后，len即为所要求的最长上升子序列的长度。

在上述算法中，若使用朴素的顺序查找在D[1]..D[len]查找，由于共有O(n)个元素需要计算，每次计算时的复杂度是O(n)，则整个算法的时间复杂度为O(n^2)，与原来的算法相比没有任何进步。但是由于D[]的特点(2)，我们在D[]中查找时，可以使用二分查找高效地完成，则整个算法的时间复杂度下降为O(nlogn)，有了非常显著的提高。需要注意的是，D[]在算法结束后记录的并不是一个符合题意的最长上升子序列！

这个算法还可以扩展到整个最长子序列系列问题，整个算法的难点在于二分查找的设计，需要非常小心注意。

补充：
1：下面程序的F数组在此题中没有用到，它是用来保存每个从1--i的最长不降子序列。
2：此程序虽然很快，但是它却丢掉了普通算法的一些优势，就是：我们如果要把最长的子序列找出来，那么就是十分的困难的啦，因为我们把原有的数据在work的时候给覆盖了，其它的方面还是十分的满意。

【参考程序】：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int f[100001],a[100001],c[100001];
int n,size;
int bsearch(int ai)
{
        int l=1,r=size,mid;
        while (l<=r)
        {
                mid=(l+r)>>1;
                if (ai<c[mid-1] && ai>=c[mid]) return mid;
                else if (ai<c[mid]) l=mid+1;
                else r=mid-1;
        }
}
int main()
{
        scanf("%d",&n);
        if (!n)
        {
                printf("0\n");
                exit(0);
        }
        for (int i=1;i<=n;i++) scanf("%d",&a[i]);
        f[1]=1;c[1]=a[1];size=1;
        for (int i=2;i<=n;i++)
        {
                if (a[i]==0) continue;
                int j;
                if (a[i]>=c[1]) j=1;
                else if (a[i]<c[size]) j=++size;
                else j=bsearch(a[i]);
                f[i]=j;c[j]=a[i];
        }
        printf("%d\n",size);
        system("pause");
        return 0;
}

开拓者 2009-04-18 17:26 发表评论

【DD牛超强0/1背包优化】

开拓者 — Thu, 09 Apr 2009 12:15:00 GMT

今天看了DD牛的《背包九讲》看到一个背包的超前优化：

题目：
有N种物品和一个容量为V的背包。第i种物品最多有n[i]件可用，每件费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。

基本算法：
这题目和完全背包问题很类似。基本的方程只需将完全背包问题的方程略微一改即可，因为对于第i种物品有n[i]+1种策略：取0件，取1件……取n[i]件。令f[i][v]表示前i种物品恰放入一个容量为v的背包的最大权值，则有状态转移方程：
f[i][v]=max{f[i-1][v-k*c[i]]+k*w[i]|0<=k<=n[i]}
复杂度是O(V*Σn[i])。

转化为01背包问题
另一种好想好写的基本方法是转化为01背包求解：把第i种物品换成n[i]件01背包中的物品，则得到了物品数为Σn[i]的01背包问题，直接求解，复杂度仍然是O(V*Σn[i])。

但是我们期望将它转化为01背包问题之后能够像完全背包一样降低复杂度。仍然考虑二进制的思想，我们考虑把第i种物品换成若干件物品，使得原问题中第i种物品可取的每种策略——取0..n[i]件——均能等价于取若干件代换以后的物品。另外，取超过n[i]件的策略必不能出现。

方法：
将第i种物品分成若干件物品，其中每件物品有一个系数，这件物品的费用和价值均是原来的费用和价值乘以这个系数。使这些系数分别为1,2,4,...,2^(k-1),n[i]-2^k+1，且k是满足n[i]-2^k+1>0的最大整数。例如，如果n[i]为13，就将这种物品分成系数分别为1,2,4,6的四件物品。
分成的这几件物品的系数和为n[i]，表明不可能取多于n[i]件的第i种物品。另外这种方法也能保证对于0..n[i]间的每一个整数，均可以用若干个系数的和表示，这个证明可以分0..2^k-1和2^k..n[i]两段来分别讨论得出(并不难，希望你自己思考尝试一下)

这样就将第i种物品分成了O(log n[i])种物品，将原问题转化为了复杂度为 $O(V*Σlog n[i])的01背包问题，是很大的改进。$

下面给出O(log amount)时间处理一件多重背包中物品的过程，其中amount表示物品的数量：

procedure MultiplePack(cost,weight,amount)
if cost*amount>=V
   CompletePack(cost,weight)
   return
integer k=1
while k<amount
  ZeroOnePack(k*cost,k*weight)
  amount=amount-k
  k=k*2
  ZeroOnePack(amount*cost,amount*weight)

dd把每一个物品的数量转换成2进制的形式，好处在于所用到的物品个数我可以用产生出来的2进制的数量去把需要的物品个数组合出来,例如：5：1 4，10：1 2 4 3（1 2），所以我们就没有必要想以前那样for所有的物品数量，减少了很多无畏的循环。

普通的优化：
做法：
对于每件物品的数量，在每次循环是我们加个判断：对于当前的for的这个物品，它最终有没有改变到哪个背包，假如它每一个背包都没有改变到，那么当前物品后面的数量也是不会改变任何的背包（他们都是一样的嘛！），所有此时我们便可跳出当前物品的循环了.（时间挺理想的，对于一般的数据是很快的）
【参考程序】：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int f[50001];
int main()
{
     freopen("duo.in","r",stdin);
     freopen("duo.out","w",stdout);
     long n,m,a,b,c;
     scanf("%d%d",&n,&m);
     memset(f,0,sizeof(f));
     for (int i=1;i<=m;i++)
     {
         scanf("%d%d%d",&a,&b,&c);
         for (int k=1;k<=a;k++)
         {
             bool bk=1;//上述的优化
             for (int j=n;j>=b;j--)
               if (f[j]<f[j-b]+c){
                 f[j]=f[j-b]+c;
                 bk=0;
             }
             if(bk) break;
         }
     }
     printf("%d\n",f[n]);
     return 0;
}

DD 牛的优化：
【参考程序】：

#include<string.h>
#include<stdio.h>
#include<stdlib.h>
long f[50001],n,m;
bool bk;
void zeroonepack(long we,long va)
{
    for (int i=n;i>=we;i--)
    {
        if (f[i-we]+va>f[i])
        {
            f[i]=f[i-we]+va;
            bk=true;
        }
    }
}
int main()
{
    freopen("duo.in","r",stdin);
    freopen("duo.out","w",stdout);
    scanf("%d%d",&n,&m);
    for (int i=0;i<=n;i++) f[i]=0;
    long amount,weight,value,k;
    for (int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&amount,&weight,&value);
        k=1;bk=false;
        while (k<=amount)
        {
            zeroonepack(k*weight,k*value);
            if (!bk) break;
            amount-=k;
            k*=2;
        }
        zeroonepack(amount*weight,amount*value);
    }
    printf("%d\n",f[n]);
    return 0;
}

开拓者 2009-04-09 20:15 发表评论

C++博客-【♂Not The Triumph♂O(∩_∩)O哈哈~But The Struggle♂】-文章分类-算法&例题

【DFSID 埃及分数】

【DFS 笨笨的炸弹安置(赛)】

【DFS 尾声-怪盗基德的逃离】

【BFS 毒药?解药?】

【记忆化搜索 Function(Function(F...】

【DFS 拯救ice-cream】

【DFS 送给圣诞夜的极光】

【树状数组 校门外的树】

【树状数组 笨笨的西瓜种植（赛）】

【网络流 笨笨的洪水堵截(賽)】

【Network of Schools 校园网】

【Milk Measuring 量取牛奶】

【Wisconsin Squares 威斯康星州的牧场】

【Snail Trails 蜗牛的旅行】

【Pascal 山脉】

【Shuttle Puzzle 棋盘游戏】

【Checker Challenge 跳棋的挑战】

【rq 大地的秘密】

【线段树之数列操作】

【HDU I Hate It】

【NlogN的最长不降子序列算法】

【DD牛超强0/1背包优化】

【树状数组校门外的树】

【树状数组笨笨的西瓜种植（赛）】

【网络流笨笨的洪水堵截(賽)】