C++博客-【♂Not The Triumph♂O(∩_∩)O哈哈~But The Struggle♂】-文章分类-Vijos OJ

【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 发表评论

【dijkstra 最佳路线】

开拓者 — Tue, 15 Sep 2009 12:24:00 GMT

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

描述 Description
年久失修的赛道令国际汽联十分不满。汽联命令主办方立即对赛道进行调整，否则将取消其主办权.主办方当然必须马上开始行动。赛道测评人员经过了三天三夜的数据采集，选出了若干可以使用的道路和各道路行驶所需的时间。这些道路包括若干直道和弯道，每个直道连接两个不同的弯道且为单向,两个弯道之间可能有多条直道，通过直道和弯道都需要一定的时间。主办方打算在这些可用道路中选出一部分作为赛道。赛道是由直道和弯道交替组成的一圈，赛道可多次经过同一条弯道，因为主办方可以通过架设立交桥的方法避免撞车。为了使比赛更加精彩，主办方希望选择一条单圈时间最短的赛道,由于观众席的位置在弯道1，所以赛道必须经过弯道1(赛道至少要包含一条直道).

输入格式 Input Format
第一行是两个整数n，m(1<=n<=200，1<=m<=100000)，分别表示弯道数和直道数。接下来n行，第i行是一个整数ai(1<=ai<=1000)，表示通过第i个弯道所消耗的时间。接下来m行，第j行是三个整数xj，yj，bj(1& lt;=xj，yj<=n，1<=bj<=1000)，表示从弯道xj到弯道yj有一条单向直道，且通过该直道所消耗的时间为bj。

输出格式 Output Format
一个整数s，表示单圈时间最短的赛道的单圈时间，若无解则输出-1。

样例输入 Sample Input
【样例输入1】
3 6
1
1
2
1 2 3
2 3 5
3 1 1
3 2 1
2 1 10
1 3 15

【样例输入2】
3 4
1 1 2
1 2 4
1 3 5
2 3 5
3 2 10

样例输出 Sample Output
【样例输出1】
13

【样例输出2】
-1

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

分析：
删边+dijkstra

【参考程序】：

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

int cost[210][210],d[210],a[210];
bool vis[210];
int n,m,ans;
int main()
{
    scanf("%d%d",&n,&m);
    for (int i=1;i<=n;i++) scanf("%d",&a[i]);
    memset(cost,0,sizeof(cost));
    int x,y,c;
    for (int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&x,&y,&c);
        if (cost[x][y]==0 || cost[x][y]>c)
            cost[x][y]=c;
    }
    int Min,p,temp;
    ans=0x7FFFFFFF;
    for (int i=1;i<=n;i++)
        if (cost[1][i]!=0)
        {
            temp=cost[1][i]; cost[1][i]=0;
            memset(d,127,sizeof(d));
            memset(vis,false,sizeof(vis));
            d[i]=0;
            for (int j=1;j<=n-1;j++)
            {
                Min=0xFFFFFFF; p=0;
                for (int k=1;k<=n;k++)
                    if (!vis[k] && d[k]<Min)
                    {
                        Min=d[k]; p=k;
                    }
                if (p==0) break;
                vis[p]=true;
                for (int k=1;k<=n;k++)
                    if (cost[p][k]!=0 && !vis[k] && d[k]>d[p]+cost[p][k]+a[k])
                        d[k]=d[p]+cost[p][k]+a[k];
            }
            cost[1][i]=temp;
            if (ans>cost[1][i]+a[i]+d[1])
                ans=cost[1][i]+a[i]+d[1];
        }
    if (ans<2100000000) printf("%d\n",ans);
    else printf("-1\n");
    return 0;
}

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

【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 发表评论

【CoVH之柯南开锁】

开拓者 — Fri, 11 Sep 2009 02:10:00 GMT

背景 Background
随着时代的演进,困难的刑案也不断增加...但真相只有一个虽然变小了,头脑还是一样好,这就是名侦探柯南!

描述 Description
面对OIBH组织的嚣张气焰, 柯南决定深入牛棚, 一探虚实.他经过深思熟虑, 决定从OIBH组织大门进入...........
OIBH组织的大门有一个很神奇的锁.锁是由M*N个格子组成, 其中某些格子凸起(灰色的格子). 每一次操作可以把某一行或某一列的格子给按下去.

如果柯南能在组织限定的次数内将所有格子都按下去, 那么他就能够进入总部. 但是OIBH组织不是吃素的, 他们的限定次数恰是最少次数.

请您帮助柯南计算出开给定的锁所需的最少次数.

输入格式 Input Format
第一行两个不超过100的正整数N, M表示矩阵的长和宽
以下N行每行M个数非0即1 1为凸起方格

输出格式 Output Format
一个整数所需最少次数

样例输入 Sample Input
4 4
0000
0101
0000
0100

样例输出 Sample Output
2

时间限制 Time Limitation
全部1秒

分析：
仔细看题后发现就是求二分图最小覆盖点集，可以用“匈牙利算法”解决，因为二分图最小覆盖点集==最大匹配数.
证明：matrix67博客 http://www.matrix67.com/blog/archives/116

【参考程序】：

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

int link[110];
bool g[110][110],vis[110];
int n,m,ans;
bool Find(int now)
{
    for (int i=1;i<=m;i++)
        if (!vis[i] && g[now][i])
        {
            vis[i]=true;
            if (link[i]==0 || Find(link[i]))
            {
                link[i]=now;
                return true;
            }
        }
    return false;
}
int main()
{
    scanf("%d%d",&n,&m); getchar();
    memset(g,false,sizeof(g));
    char c;
    for (int i=1;i<=n;i++)
    {
        for (int j=1;j<=m;j++)
        {
            scanf("%c",&c);
            if (c=='1') g[i][j]=true;
        }
        getchar();
    }
    memset(link,0,sizeof(link));
    ans=0;
    for (int i=1;i<=n;i++)
    {
        memset(vis,false,sizeof(vis));
        if (Find(i)) ans++;
    }
    printf("%d\n",ans);
    return 0;
}

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

【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 发表评论

【并查集口袋的天空】

开拓者 — Sun, 06 Sep 2009 12:51:00 GMT

背景 Background
小杉坐在教室里，透过口袋一样的窗户看口袋一样的天空。
有很多云飘在那里，看起来很漂亮，小杉想摘下那样美的几朵云，做成棉花糖。

描述 Description
给你云朵的个数N，再给你M个关系，表示哪些云朵可以连在一起。
现在小杉要把所有云朵连成K个棉花糖，一个棉花糖最少要用掉一朵云，小杉想知道他怎么连，花费的代价最小。

输入格式 Input Format
每组测试数据的
第一行有三个数N,M,K(1<=N<=1000,1<=M<=10000,1<=K<=10)
接下来M个数每行三个数X,Y,L，表示X云和Y云可以通过L的代价连在一起。(1<=X,Y<=N,0<=L<10000)
30%的数据N<=100,M<=1000

输出格式 Output Format
对每组数据输出一行，仅有一个整数，表示最小的代价。
如果怎么连都连不出K个棉花糖，请输出'No Answer'。

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

样例输出 Sample Output
1

时间限制 Time Limitatio
每个测试点1s

注释 Hint
样例2：
Input:
3 1 1
1 2 1

Output:
No Answer

分析：
这个题其实很简单，就是尽量生成最小生成树（用克鲁斯卡尔算法，PS：传说中的kruskal，先排序，后贪心的算法），有可能图不是连通的，也就是，给的数据是好几个图，这样，我们将要求的最小生成树的个数设为k，我们生成的最小生成树的个数是m，若m=k，则直接输出代价就可以了，如果m>k则说明图的个数比要求的最小生成树个数小，怎么也无法构成k个最小生成树，也就是输出"No Answer"
如果m

【参考程序】：

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

struct node
{
    int x,y,c;
} list[10010];
int fa[1010],cost[1010];
bool used[10010];
int n,m,k;
int cmp(const void *s,const void *t)
{
    node i=*(node *)s,j=*(node *)t;
    return i.c-j.c;
}
int Find(int x)
{
    if (fa[x]!=x) fa[x]=Find(fa[x]);
    return fa[x];
}
int main()
{
    scanf("%d%d%d",&n,&m,&k);
    for (int i=1;i<=m;i++)
        scanf("%d%d%d",&list[i].x,&list[i].y,&list[i].c);
    qsort(list+1,m,sizeof(node),cmp);
    for (int i=1;i<=n;i++)
    {
        fa[i]=i; cost[i]=0;
    }
    memset(used,false,sizeof(used));
    int x,y;
    for (int i=1;i<=m;i++)
    {
        x=Find(list[i].x);
        y=Find(list[i].y);
        if (x!=y)
        {
            used[i]=true;
            fa[y]=x;
            cost[x]+=cost[y]+list[i].c;
        }
    }
    int Max,scost,cut;
    bool bk;
    Max=0;
    for (int i=1;i<=n;i++)
        if (fa[i]==i) Max++;
    if (Max>k) printf("No Answer\n");
    else
    {
        scost=0;
        for (int i=1;i<=n;i++)
            if (fa[i]==i) scost+=cost[i];
        if (Max==k) printf("%d\n",scost);
        else
        {
            cut=0; bk=false;
            for (int i=m;i>=1;i--)
                if (used[i])
                {
                    cut++;
                    scost-=list[i].c;
                    if (Max+cut==k)
                    {
                        bk=true; break;
                    }
                }
            if (!bk) printf("No Answer\n");
            else printf("%d\n",scost);
        }
    }
    return 0;
}

【参考程序】：//pascal

Type jilu=record
     f,t,l:integer;
End;
Var n,m,k,i,s,max,cut:longint;
    map:array[1..10000]of jilu;
    use:array[1..10000]of boolean;
    father,cost:array[1..1000]of longint;
    bool:boolean;
    x,y:integer;
Function find(now:integer):integer;
Begin
   While father[father[now]]<>father[now] do
      father[now]:=father[father[now]];
   find:=father[now];
End;
Procedure csfp(be,en:integer);
Var x,y:integer;
    bz:jilu;
Begin
   x:=be; y:=en; bz:=map[be];
   While x<y do
   Begin
       While (x<y)and(map[y].l>=bz.l) do dec(y);
       map[x]:=map[y];
       While (x<y)and(map[x].l<=bz.l) do inc(x);
       map[y]:=map[x];
   End;
   map[x]:=bz;
   If be<=x-1 Then csfp(be,x-1);
   If x+1<=en Then csfp(x+1,en);
End;
Begin
   Readln(n,m,k);
   For i:= 1 to m do
      Readln(map[i].f,map[i].t,map[i].l);
   csfp(1,m);
   For i:= 1 to n do father[i]:=i;
   For i:= 1 to m do
   Begin
      x:=find(map[i].f);
      y:=find(map[i].t);
      If x<>y Then
      Begin
         use[i]:=true;
         father[y]:=x;
         cost[x]:=cost[x]+cost[y]+map[i].l;
      End;
   End;
   For i:= 1 to n do
     If father[i]=i Then inc(max);
   If max>k Then Writeln('No Answer')
   Else
   Begin
      For i:= 1 to n do
        If father[i]=i Then s:=s+cost[i];
      If k=max Then Writeln(s)
      Else
      Begin
          bool:=false;
          For i:= m downto 1 do
            If use[i] Then
            Begin
                inc(cut);
                s:=s-map[i].l;
                If max+cut=k Then
                Begin
                    Bool:=true; Break;
                End;
            End;
          If bool Then Writeln(s)
          Else Writeln('No Answer');
      End;
   End;
End.

开拓者 2009-09-06 20:51 发表评论

【Way Selection (匈牙利算法)】

开拓者 — Fri, 04 Sep 2009 02:03:00 GMT

背景 Background
小杉家族遭遇了前所未有的大危机
他想知道怎么逃生

描述 Description
小杉家族r个人正在一片空地上散步，突然，外星人来了……留给小杉家族脱逃的时间只有t秒，每个小杉都有一个跑的速度v总共有a个传送点，小杉们必须在t秒内到达传送点才能脱逃另外一个小杉进入一个传送点以后，该传送点就会消失现在请你安排一种方案，使脱逃的小杉尽可能的多

输入格式 Input Format
每组测试数据的
第一行有三个整数r和a和t(0第二行有a对实数，第i对数表示第i个传送点的坐标，这些坐标绝对值均不超过1e6
接下来r行，每行有三个实数x,y,v，表示第i个小杉的坐标和奔跑的速度

输出格式 Output Format
对每组测试数据输出一行
仅有一个整数s表示最多有多少个小杉能成功脱逃

样例输入 Sample Input
1 1 1
1 1
1 1 1

样例输出 Sample Output
1

分析:
其实就是一个"匈牙利算法"(二分图的最大匹配),重点就是在于如何构图，其实也是很简单：对于每个传送点J，如果有第i个小彬的坐标到此点(传送点)的距离(dis)小于等于第i个小彬所走的路程(即：dis<=t*v(第i小彬的速度))则可以连边，这样就可以构造出图来啦. 最后就是用一个朴素的"匈牙利"即可。

【参考程序】：

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

int Link[1010];
bool g[1010][1010],vis[1010];
double x[1010],y[1010];
int n,m,t,ans;
bool Find(int now)
{
    for (int i=1;i<=m;i++)
        if (g[now][i] && !vis[i])
        {
            vis[i]=true;
            if (Link[i]==0 || Find(Link[i]))
            {
                Link[i]=now;
                return true;
            }
        }
    return false;
}
int main()
{
    scanf("%d%d%d",&m,&n,&t);
    memset(g,false,sizeof(g));
    for (int i=1;i<=n;i++)
        scanf("%lf%lf",&x[i],&y[i]);
    double x1,y1,v,dis;
    for (int i=1;i<=m;i++)
    {
        scanf("%lf%lf%lf",&x1,&y1,&v);
        for (int j=1;j<=n;j++)
        {
            dis=sqrt((x1-x[j])*(x1-x[j])+(y1-y[j])*(y1-y[j]));
            if (v*t>=dis) g[j][i]=true;
        }
    }
    ans=0;
    memset(Link,0,sizeof(Link));
    for (int i=1;i<=n;i++)
    {
        memset(vis,false,sizeof(vis));
        if (Find(i)) ans++;
    }
    printf("%d\n",ans);
    return 0;
}

开拓者 2009-09-04 10:03 发表评论

【Vs Liqeuer】

开拓者 — Mon, 31 Aug 2009 02:20:00 GMT

背景 Background
在突破了重重难关后，工藤根据前三人留下的信息来到了一个充满实验室味道的房间……一道强光闪过..一个神秘而又熟悉的身影随着漫天飞舞的雪花徐徐下落。 "高中生侦探工藤新一，果然名不虚传……""这声音……你是！""在下Liqeuer，恭候多时了。" 隐约闪现的面孔……"你是maa04！""哼，没想到吧……想要救回小兰？过我这关吧！" "出招吧！"
(轰的一声，Liqeuer——maa04，即笨笨身后的一扇门迅速打开，展现在眼前的是两堆零件和一条岩浆“河”)

描述 Description
我们将第一堆零件定义为集合S1，第二堆定义为集合S2。
首先，S1的零件个数少于等于S2的零件个数。我们现在设N为S1的零件个数，从S2中挑选出N个零件，使得两个集合的匹配差最小。这样搭建出来的桥才能顺利通过岩浆“河”。

对于两个集合的匹配差在本题定义作此描述：
定义F（S1，S2）=min(|a1-b1|+|a2-b2|+|a3-b3|+...+|an-bn|){n为S1的元素个数，ai∈S1，bi∈S2}，F(S1，S2)即为两个集合的匹配差。

输入格式 Input Format
第一行一个数testcase，表示测试数据组数(0<=testcase<=20)
每组数据的格式如下：
第一行两个数n1,n2(0<=n1<=n2<=500)，n1表示第一堆零件的个数，n2表示第二堆零件的个数。
接下来n1行，每行一个数，表示S1的各个元素(不超过10000)。
再接下来n2行，每行一个数，表示S2的各个元素(同样不超过10000)。

输出格式 Output Format
输出testcase行，每行一个数。
第i行表示第i组数据的两个集合的匹配差值的最小值。

样例输入 Sample Input
3
10 10
1
2
3
4
5
6
7
8
9
20
10
11
12
13
14
15
16
17
18
19
4 5
1
2
3
4
5
6
7
8
9
8 12
3
4
6
8
10
16
21
25
29
34
25
12
42
35
62
19
31
49
46
37

样例输出 Sample Output
82
16
129

分析：
qsort+Dp;
f[i,j]表示S2选前j个匹配S1的前i个的最小值。

【参考程序】：

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

int a[510],b[510],F[510][510];
int n,m,t;
int cmp(const void *s,const void *t)
{
    int i=*(int *)s,j=*(int *)t;
    return i-j;
}
void solve()
{
    memset(F,0,sizeof(F));
    for (int i=0;i<=m;i++)
        for (int j=0;j<=n;j++)
            F[i][j]=1000000000;
    for (int i=0;i<=n;i++) F[0][i]=0;
    for (int i=1;i<=m;i++)
        for (int j=1;j<=n;j++)
            if (F[i][j-1]<F[i-1][j-1]+abs(a[i]-b[j]))
                F[i][j]=F[i][j-1];
            else F[i][j]=F[i-1][j-1]+abs(a[i]-b[j]);
}
int main()
{
    scanf("%d",&t);
    for (int o=1;o<=t;o++)
    {
        scanf("%d%d",&m,&n);
        for (int i=1;i<=m;i++) scanf("%d",&a[i]);
        for (int i=1;i<=n;i++) scanf("%d",&b[i]);
        qsort(a+1,m,sizeof(int),cmp);
        qsort(b+1,n,sizeof(int),cmp);
        solve();
        printf("%d\n",F[m][n]);
    }
    return 0;
}

开拓者 2009-08-31 10:20 发表评论

【NOIP 2005 等价表达式】

开拓者 — Sun, 30 Aug 2009 03:47:00 GMT

【问题描述】
明明进了中学之后，学到了代数表达式。有一天，他碰到一个很麻烦的选择题。这个题目的题干中首先给出了一个代数表达式，然后列出了若干选项，每个选项也是一个代数表达式，题目的要求是判断选项中哪些代数表达式是和题干中的表达式等价的。

这个题目手算很麻烦，因为明明对计算机编程很感兴趣，所以他想是不是可以用计算机来解决这个问题。假设你是明明，能完成这个任务吗？

这个选择题中的每个表达式都满足下面的性质：
1．表达式只可能包含一个变量‘a’。
2．表达式中出现的数都是正整数，而且都小于10000。
3．表达式中可以包括四种运算‘+’（加），‘-’（减），‘*’（乘），‘^’（乘幂），以及小括号‘(’，‘)’。小括号的优先级最高，其次是‘^’，然后是‘*’，最后是‘+’和‘-’。‘+’和‘-’的优先级是相同的。相同优先级的运算从左到右进行。（注意：运算符‘+’，‘-’，‘*’，‘^’以及小括号‘(’，‘)’都是英文字符）
4．幂指数只可能是1到10之间的正整数（包括1和10）。
5．表达式内部，头部或者尾部都可能有一些多余的空格。

下面是一些合理的表达式的例子：

((a^1) ^ 2)^3，a*a+a-a，((a+a))，9999+(a-a)*a，1 + (a -1)^3，1^10^9……

【输入文件】
输入文件equal.in的第一行给出的是题干中的表达式。第二行是一个整数n（2 <= n <= 26），表示选项的个数。后面n行，每行包括一个选项中的表达式。这n个选项的标号分别是A，B，C，D……
输入中的表达式的长度都不超过50个字符，而且保证选项中总有表达式和题干中的表达式是等价的。

【输出文件】
输出文件equal.out包括一行，这一行包括一系列选项的标号，表示哪些选项是和题干中的表达式等价的。选项的标号按照字母顺序排列，而且之间没有空格。

【样例输入】
( a + 1) ^2
3
(a-1)^2+4*a
a + 1+ a
a^2 + 2 * a * 1 + 1^2 + 10 -10 +a –a

【样例输出】
AC

【数据规模】
对于30%的数据，表达式中只可能出现两种运算符‘+’和‘-’；
对于其它的数据，四种运算符‘+’，‘-’，‘*’，‘^’在表达式中都可能出现。
对于全部的数据，表达式中都可能出现小括号‘(’和‘)’。

【参考程序】：

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

typedef struct
{
    char op;
    long long v;
    bool ok;
}node1;

typedef struct
{
    int cnt;
    node1 I[1010];
}node2;

node2 E[30],H[30];
int w[255];
int N;

bool big(char o1,char o2)
{
    if (o1=='(') return true;
    if (o2=='(') return true;
    return w[o1]>w[o2];
}
void postfix(int Q)
{
    char stack1[1010];
    int top=0,p=0;
    stack1[0]='@';
    for (int i=1;i<=E[Q].cnt;i++)
    {
        if (E[Q].I[i].op==0)
        {
            H[Q].I[++p].v=E[Q].I[i].v;
            H[Q].I[p].ok=E[Q].I[i].ok;
        }
        else
        {
            if (E[Q].I[i].op==')')
            {
                while (stack1[top]!='(')
                {
                    H[Q].I[++p].op=stack1[top];
                    stack1[top--]=0;
                }
                stack1[top--]=0;
            }
            else if (big(E[Q].I[i].op,stack1[top]))
                stack1[++top]=E[Q].I[i].op;
            else
            {
                while (!big(E[Q].I[i].op,stack1[top]) && top>0)
                {
                    H[Q].I[++p].op=stack1[top];
                    stack1[top--]=0;
                }
                stack1[++top]=E[Q].I[i].op;
            }
        }
    }
    H[Q].cnt=p;
}

long long power(long long a,long long b)
{
    long long Q=1;
    for (int i=1;i<=b;i++) Q*=a;
    return Q;
}
long long evaluate(int Q)
{
    int top=-1;
    long long stack1[1010],a,b;
    for (int i=1;i<=H[Q].cnt;i++)
    {
        if (H[Q].I[i].op==0)
        {
            stack1[++top]=H[Q].I[i].v;
        }
        else
        {
            b=stack1[top--]; a=stack1[top--];
            switch(H[Q].I[i].op)
            {
                case '+':
                    stack1[++top]=a+b;
                    break;
                case '-':
                    stack1[++top]=a-b;
                    break;
                case '*':
                    stack1[++top]=a*b;
                    break;
                case '/':
                    stack1[++top]=a/b;
                    break;
                case '^':
                    stack1[++top]=power(a,b);
                    break;
            }
        }
    }
    return stack1[0];
}
bool is_operator(char c)
{
    return (c=='+' || c=='-' || c=='*' || c=='/' || c=='^' || c=='(' ||c==')');
}

void readf(int Q)
{
    int i=0; char c;
    while (!cin.eof())
    {
        while ((c=cin.get())==' ');
            if (c==10 || c==13 || cin.eof()) break;
        i++;
        if (is_operator(c)) E[Q].I[i].op=c;
        else if (c=='a') E[Q].I[i].ok=true;
        else
        {
            cin.putback(c);
            E[Q].I[i].op=0;
            cin >> E[Q].I[i].v;
        }
    }
    E[Q].I[ E[Q].cnt=i+1 ].op='@';
}
void replace_letter(int P)
{
    int i,j;
    for (i=0;i<=N;i++)
        for (j=1;j<=H[i].cnt;j++)
            if (H[i].I[j].ok) H[i].I[j].v=P;
}

void solve()
{
    long long A,B,C;
    bool right[30];
    for (int i=1;i<=N;i++) right[i]=true;
    for (int i=1;i<=10;i++)
    {
        replace_letter(rand()%100);
        A=evaluate(0);
        for (int j=1;j<=N;j++)
        {
            B=evaluate(j); C=A-B;
            if (C<0) C=-C;
            if (C>0.1) right[j]=false;
        }
    }
    for (int i=1;i<=N;i++)
        if (right[i]) printf("%c",i-1+'A');
    printf("\n");
}

int main()
{
    w['@']=0; w['^']=3;
    w['+']=w['-']=1;
    w['*']=w['/']=2;
    readf(0); postfix(0);
    cin>>N; getchar();
    for (int i=1;i<=N;i++)
    {
        readf(i); postfix(i);
    }
    solve();
    return 0;
}

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

【zgx跳棋游戏之二】

开拓者 — Sat, 29 Aug 2009 03:12:00 GMT

有2n个棋子(n>=4)排成一行，开始时白子全在左边，黑子全在右边，最右边有两个空格：
OOOO****__(n=4);

要求把它移成黑白相见的一行棋子：
__O*O*O*O*;
移动规则是：每次必须同时移动相邻的2个棋子，颜色不限；但不能调换2个棋子的左右位置。移动必须跳过若干个棋子到左边或右边的空位上去（不能平移）。

输入格式 Input Format
n小于等于100

输出格式 Output Format
初始到目标的所有步骤，具体看样例。

样例输入 Sample Input
4

样例输出 Sample Output
step 0:OOOO****__
step 1:OOO__***O*
step 2:OOO*O**__*
step 3:O__*O**OO*
step 4:O*O*O*__O*
step 5:__O*O*O*O*

分析：
有规律可寻。

【参考程序】：

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

string s,ans;
int n;
int main()
{
    cin>>n;
    s="";
    for (int i=0;i<n;i++) s+='O';
    for (int i=0;i<n;i++) s+='*';
    s+="__";
    int x=n,tot=0;
    cout<<"step "<<tot<<":"<<s<<endl;
    tot++;
    while (x>4)
    {
        s[x-1]='_'; s[x]='_'; s[2*x]='O'; s[2*x+1]='*';
        cout<<"step "<<tot<<":"<<s<<endl;
        tot++;
        s[2*x-1]='_'; s[2*x-2]='_'; s[x-1]='*'; s[x]='*';
        cout<<"step "<<tot<<":"<<s<<endl;
        x--;
        tot++;
    }
    ans=s.substr(10,(n-4)*2);
    cout<<"step "<<tot<<":"<<"OOO__***O*"+ans<<endl; tot++;
    cout<<"step "<<tot<<":"<<"OOO*O**__*"+ans<<endl; tot++;
    cout<<"step "<<tot<<":"<<"O__*O**OO*"+ans<<endl; tot++;
    cout<<"step "<<tot<<":"<<"O*O*O*__O*"+ans<<endl; tot++;
    cout<<"step "<<tot<<":"<<"__O*O*O*O*"+ans<<endl; tot++;
    return 0;
}

【参考程序】：//pascal

var s,ans:string;
      n,total,i,x:longint;
begin
  readln(n);
  for i:=1 to n do
    s:=s + 'O';
  for i:=1 to n do
    s:=s + '*';
  s:=s + '__';
  x:=n;
  writeln('step ',total,':',s);
  inc(total);
  while x > 4 do
  begin
     s[x]:='_'; s[x+1]:='_'; s[2*x+1]:='O'; s[2*x+2]:='*';
      writeln('step ',total,':',s);
      inc(total);
      s[2*x]:='_'; s[2*x-1]:='_'; s[x]:='*'; s[x+1]:='*';
      dec(x);
     writeln('step ',total,':',s);
     inc(total);
  end;
  ans:=copy(s,11,(n-4)*2);
  writeln('step ',total,':OOO__***O*'+ans); inc(total);
  writeln('step ',total,':OOO*O**__*'+ans); inc(total);
  writeln('step ',total,':O__*O**OO*'+ans); inc(total);
  writeln('step ',total,':O*O*O*__O*'+ans); inc(total);
  writeln('step ',total,':__O*O*O*O*'+ans); inc(total);
end.

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

【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 发表评论

【vijos 小胖守皇宫】

开拓者 — Tue, 25 Aug 2009 03:29:00 GMT

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

描述 Description
huyichen世子事件后，xuzhenyi成了皇上特聘的御前一品侍卫。
皇宫以午门为起点，直到后宫嫔妃们的寝宫，呈一棵树的形状；有边相连的宫殿间可以互相望见。大内保卫森严，三步一岗，五步一哨，每个宫殿都要有人全天候看守，在不同的宫殿安排看守所需的费用不同。

可是xuzhenyi手上的经费不足，无论如何也没法在每个宫殿都安置留守侍卫。
帮助xuzhenyi布置侍卫，在看守全部宫殿的前提下，使得花费的经费最少。

输入格式 Input Format 输入文件中数据表示一棵树，描述如下：
第1行 n，表示树中结点的数目。
第2行至第n+1行，每行描述每个宫殿结点信息，依次为：该宫殿结点标号i（0

对于一个n（0 < n <= 1500）个结点的树，结点标号在1到n之间，且标号不重复。

输出格式 Output Format
输出文件仅包含一个数，为所求的最少的经费。

Input：
6
1 30 3 2 3 4
2 16 2 5 6
3 5 0
4 4 0
5 11 0
6 5 0
Output：
25

分析：
大概思路，分三种情况，某个节点可能的三种情况，一是自己染色，二是由子
节点染色，三是自己不染色，也不由子节点来担心，就把这个任务交给该节点的父
节点了，这三种情况用不同的域来存。
　　第一规划：该节点自己染色，子节点们就用自己三个域中的最小值（想一想为
什么）
　　第二规划：该节点由孩子来染色，但是由哪一个孩子来染色呢？不知道吧，那
就枚举先，枚举子节点作为控制父节点的节点，其他节点全部用作能染色的类型，
累加选最小的。
　　第三规划：自己不染色，孩子也不来，就把这个任务交给父节点，那么该节点
没有染色，该节点的子节点就必须能够自己染色，这种自己染色的情况又有两种，
选一种最小的累加起来。

【参考程序】：

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

const int Max=100000000;
int last[1600],money[1600],F[1600][4];
int pre[3200],child[3200];
bool vis[1600];
int n,root;
int Min(int x,int y)
{
    return x<y?x:y;
}
void dfs(int x)
{
    int y,y1,sum,num,dis;
    vis[x]=true; F[x][1]=money[x];
    F[x][2]=0; F[x][3]=0; num=0; sum=0;
    y1=last[x];
    while (last[x]>0)
    {
        y=child[last[x]];
        if (!vis[y])
        {
            dfs(y); num++;
            F[x][1]+=Min(F[y][1],Min(F[y][2],F[y][3]));
            F[x][2]+=Min(F[y][2],F[y][1]);
            if (F[y][2]==Min(F[y][1],F[y][2])) sum++;
            F[x][3]+=F[y][2];
            if (F[x][3]>Max) F[x][3]=Max;
        }
        last[x]=pre[last[x]];
    }
    if (sum==num && y1>0)
    {
        dis=0xFFFFFFF;
        last[x]=y1;
        while (last[x]>0)
        {
            y=child[last[x]];
            if (F[y][1]-F[y][2]<dis) dis=F[y][1]-F[y][2];
            last[x]=pre[last[x]];
        }
        F[x][2]+=dis;
    }
    else if (y1==0) F[x][2]=Max;
}
int main()
{
    //freopen("guard.in","r",stdin);
    //freopen("guard.out","w",stdout);
    scanf("%d",&n); root=n*(n+1)/2;
    int c=0,x,y,k;
    memset(vis,false,sizeof(vis));
    memset(last,0,sizeof(last));
    memset(pre,0,sizeof(pre));
    for (int i=1;i<=n;i++)
    {
        scanf("%d",&x); scanf("%d",&money[x]);
        scanf("%d",&k);
        for (int j=1;j<=k;j++)
        {
            scanf("%d",&y);
            c++; pre[c]=last[x]; child[c]=y; last[x]=c;
            c++; pre[c]=last[y]; child[c]=x; last[y]=c;
            if (!vis[y])
            {
                root-=y; vis[y]=true;
            }
        }
    }
    memset(vis,false,sizeof(vis));
    dfs(root);
    printf("%d\n",Min(F[root][1],F[root][2]));
    return 0;
}

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

【vijos 添加括号】

开拓者 — Sun, 23 Aug 2009 01:44:00 GMT

背景 Background
给定一个正整数序列a(1)，a(2)，...，a(n),(1<=n<=20)
不改变序列中每个元素在序列中的位置，把它们相加，并用括号记每次加法所得的和，称为中间和。
例如:
给出序列是4，1，2，3。
第一种添括号方法:
((4+1)+(2+3))=((5)+(5))=(10)
有三个中间和是5，5，10，它们之和为:5+5+10=20
第二种添括号方法
(4+((1+2)+3))=(4+((3)+3))=(4+(6))=(10)
中间和是3，6，10，它们之和为19。

描述 Description
现在要添上n-1对括号，加法运算依括号顺序进行，得到n-1个中间和，求出使中间和之和最小的添括号方法。

输入格式 Input Format
共两行。
第一行，为整数n。(1<=n<=20)
第二行，为a(1),a(2),...,a(n)这n个正整数，每个数字不超过100。

输出格式 Output Format
输出3行。
第一行，为添加括号的方法。
第二行，为最终的中间和之和。
第三行，为n-1个中间和，按照从里到外，从左到右的顺序输出。

样例输入 Sample Input
4
4 1 2 3

样例输出 Sample Output
(4+((1+2)+3))
19
3 6 10

【参考程序】：

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

int a[50],sum[50],F[100][100],cut[100][100];
int n;
void cout2(int i,int j)
{
    if (i>=j) return ;
    cout2(i,cut[i][j]);
    cout2(cut[i][j]+1,j);
    printf("%d ",sum[j]-sum[i-1]);
}
void cout1(int i,int j)
{
    if (i>=j)
    {
        printf("%d",a[i]); return ;
    }
    printf("("); cout1(i,cut[i][j]);
    printf("+"); cout1(cut[i][j]+1,j);
    printf(")");
}
int main()
{
    scanf("%d",&n);
    sum[0]=0;
    for (int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
        sum[i]=sum[i-1]+a[i];
        F[i][i]=0; cut[i][i]=i;
    }
    int j,p,Min;
    for (int len=2;len<=n;len++)
        for  (int i=1;i<=n-len+1;i++)
        {
            j=i+len-1; Min=0xFFFFFFF;
            for (int k=i;k<=j-1;k++)
                if (F[i][k]+F[k+1][j]<=Min)
                {
                    Min=F[i][k]+F[k+1][j];
                    p=k;
                }
            cut[i][j]=p;
            F[i][j]=Min+sum[j]-sum[i-1];
        }
    cout1(1,n);
    printf("\n%d\n",F[1][n]);
    cout2(1,n); printf("\n");
    return 0;
}

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

【NOIP 2001 数的计数】

开拓者 — Sat, 22 Aug 2009 08:32:00 GMT

Description
先输入一个自然数n(n≤3000000)，然后对此自然数按照如下方法进行处理
1•不作任何处理:
2•在它的左边加上一个自然数，但该自然数不能超过原数的一半;
3•加上数后，继续按此规则进行处理，直到不能再而自然数为止。
例如
n=6
6
16
26
126
36
136
所以满足要求的个数为6。

Input
一个整数n(1<=n<=3000000)

Output
一个整数,表示解的个数(保证不超过50位)

Sample Input
6

Sample Output
6

分析：
用f[n]表示最后一个数是n时，可以构造出的数的总数。规定f[0]=1，则显然有f[n]=f[0]+f[1]+...+f[n div 2]。
　但若直接使用这个方程，则会既TLE又MLE。注意到右边其实是f数组开头若干个元素的和，因此可开一个s数组，用s[n]来存储f[0]至f[n]的和。这样时间上显然没有问题。实际上，现在f数组已经不必要了，因为用s数组可写出如下状态转移方程：s[n]=s[n-1]+f[n]=s[n-1]+s[n div 2]。当读入n时，输出s[n div 2]即可。
　结果很大，高精度是当然的。可以用3个int64来存储一个数。这里我们看到用s数组代替f数组同样解决了MLE的问题，因为s数组的大小只有f数组的一半，题目允许的内存不能容纳f数组，却恰好可以容纳s数组。

【参考程序1】：//NOIP 2001 普及组 n<=1000

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

int n,ans;
void dfs(int n)
{
    ans++;
    for (int i=1;i<=n/2;i++)
        dfs(i);
}
int main()
{
    scanf("%d",&n);
    ans=0;
    dfs(n);
    printf("%d\n",ans);
    return 0;
}

【参考程序2】://加强版

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

const int maxn=1500002;
__int64 s[maxn][3];
int n;
void print(__int64 a)
{
    char ch[60];
    sprintf(ch,"%I64d",a);
    for (int i=strlen(ch);i<=17;i++) printf("0");
    printf("%s",ch);
}
void cout_ans(__int64 a,__int64 b,__int64 c)
{
    if (a>0)
    {
        printf("%I64d",a);
        print(b);print(c);
    }
    else if (b>0)
    {
        printf("%I64d",b); print(c);
    }
    else printf("%I64d",c);
    printf("\n");
}
int main()
{
    __int64 base;
    base=(__int64)(pow(10.0,9.0)); base*=base;
    memset(s,0,sizeof(s));
    s[0][0]=1;
    for (int i=1;i<=maxn;i++)
        for (int j=0;j<=2;j++)
        {
            s[i][j]+=s[i-1][j]+s[i>>1][j];
            if (s[i][j]>=base)
            {
                s[i][j+1]++; s[i][j]-=base;
            }
        }
    while (scanf("%d",&n)!=EOF)
    {
        n=n>>1;
        cout_ans(s[n][2],s[n][1],s[n][0]);
    }
    return 0;
}

【参考程序】：//pascal

const maxb=1000000000;
      maxn=1500000;
var f:array[0..maxn+1,0..7] of longint;
    i,j,t,n:longint;
    s:string;
begin
    f[0,1]:=1;f[0,0]:=1;
    for i:=1 to maxn do
    begin
        f[i]:=f[i-1];
        t:=i shr 1;
        for j:=1 to f[i,0] do
        begin
            inc(f[i,j],f[t,j]);
            if f[i,j]>=maxb then
            begin
                inc(f[i,j+1],f[i,j]div maxb);
                f[i,j]:=f[i,j] mod maxb;
            end;
        end;
        if f[i,f[i,0]+1]<>0 then inc(f[i,0]);
    end;
    while not (eof) do
    begin
        readln(n);
        i:=n shr 1;
        t:=f[i,0];
        write(f[i,t]);
        for j:=t-1 downto 1 do
        begin
            str(f[i,j],s);
            while length(s)<9 do s:='0'+s;
            write(s);
        end;
        writeln;
    end;
end.

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

【三取方格数】

开拓者 — Sat, 22 Aug 2009 01:55:00 GMT

Description
【题目背景】
JerryZhou同学经常改编习题给自己做。
这天，他又改编了一题。。。。。

【问题描述】
设有N*N的方格图，我们将其中的某些方格填入正整数，
而其他的方格中放入0。
某人从图得左上角出发，可以向下走，也可以向右走，直到到达右下角。
在走过的路上，他取走了方格中的数。（取走后方格中数字变为0）
此人从左上角到右下角共走3次，试找出3条路径，使得取得的数总和最大。

Input
第一行:N (4<=N<=20).
接下来一个N*N的矩阵，矩阵中每个元素不超过80，不小于0.

Output
一行，表示最大的总和。

Sample Input
4
1 2 3 4
2 1 3 4
1 2 3 4
1 3 2 4

Sample Output
39

分析：
以对角线为状态，则可以将维数压缩至4维，因为每一个状态k=x+y-1;而状态k最多是2*n个。
状态方程：F[k][i1][i1][i3]表示第k个状态在横左边为(i1,i2,i3)是的最大值(此时的纵坐标是可以用上面退出来的)。
状态转移：F[k][i1][i2][i3]=max(F[k-1][i1的八种移动情况][i2的八种移动情况][i3的八种移动情况])+x
x是当三人走到(x,y)这个格子的情况时的最优值。

【参考程序】：

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

const int dir[3][8]={
{-1,-1,-1,0,0,0,-1,0},
{-1,-1,0,-1,0,-1,0,0},
{-1,0,-1,-1,-1,0,0,0}
};
int F[60][30][30][30],a[30][30];
int n;
int Max(int x,int y)
{
    if (x>y) return x;
    else return y;
}
int main()
{
    scanf("%d",&n);
    for (int i=1;i<=n;i++)
        for (int j=1;j<=n;j++)
            scanf("%d",&a[i][j]);
    memset(F,0,sizeof(F));
    int x;
    for (int k=2;k<=2*n;k++)
        for (int i1=1;i1<=k-1;i1++)
            for (int i2=1;i2<=k-1;i2++)
                for (int i3=1;i3<=k-1;i3++)
                {
                    x=a[i1][k-i1]+a[i2][k-i2]+a[i3][k-i3];
                    if (i1==i2 && i1!=i3) x=a[i1][k-i1]+a[i3][k-i3];
                    if (i1==i3 && i2!=i3) x=a[i1][k-i1]+a[i2][k-i2];
                    if (i2==i3 && i1!=i3) x=a[i2][k-i2]+a[i1][k-i1];
                    if (i1==i2 && i2==i3) x=a[i1][k-i1];
                    for (int i=0;i<=7;i++)
                        F[k][i1][i2][i3]=Max(F[k][i1][i2][i3],F[k-1][i1+dir[0][i]][i2+dir[1][i]][i3+dir[2][i]]);
                    F[k][i1][i2][i3]+=x;
                }
    printf("%d\n",F[2*n][n][n][n]);
    return 0;
}

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

【环游大同80天】

开拓者 — Fri, 21 Aug 2009 13:16:00 GMT

Description

一年一度的xuzhenyiOI2006在风景如画的大同中学举行。按照以往惯例，在激烈的比赛过程后，选手们会应邀去风景名胜区游览。今年当然也不例外。为了确定一条最佳的旅游路线，组委会请各位选手编一程序帮忙寻找。假设所有的风景点都集中在一个C列R行的矩阵中，矩阵的每一元素代表风景点或者障碍物。现在你要寻找一条满足下列条件的最佳旅游路线：
　　●这条路线上的每一点结点必须是风景点（即不能为障碍物）
　　●每个风景点最多游览一次
　　●这条路线必须是连续的相邻风景点的序列（若风景点A和B分别位于矩阵的位置（a1，a2）及（b1，b2），且|a1-b1|+|a2-b2|=1，则风景点A和B是相邻的）
　　●在满足上述条件下，游览的风景点尽可能多
假设任意的两个风景点都有且仅有一条路径（无回路）相连。显然，任意一个风景点都可以作为游览路线的起点或者终点。

输入格式 Input Format
第一行是两个整数C和R（3≤C，R≤1000），表示矩阵的列数和行数。
接下来有R行，每行有C个字符，每个字符都只能是‘#’或‘．’，‘#’表示障碍物，‘．’表示风景点。行手行末无多余空格。

输出格式 Output Format
只有一行，输出最佳路线的长度。

样例输入 Sample Input
3 3
###
#.#
###

样例输出 Sample Output
0

分析：
第一次从任意的一个可行点DFS找到一条最长的路径，再以最后找到的那个点再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[1010][1010];
bool vis[1010][1010];
int n,m,ans,xn,ym;
bool check(int x,int y)
{
    if (x>0 && x<=n && y>0 && y<=m && map[x][y]=='.')
        return true;
    return false;
}
void dfs(int x,int y,int dep)
{
    if (dep>ans)
    {
        ans=dep;
        xn=x;ym=y;
        //return ;
    }
    vis[x][y]=true;
    int tx,ty;
    for (int i=0;i<=3;i++)
    {
        tx=x+dx[i]; ty=y+dy[i];
        if (!vis[tx][ty] && check(tx,ty)) dfs(tx,ty,dep+1);
    }
    vis[x][y]=false;
}
void get()
{
    memset(vis,false,sizeof(vis));
    for (int i=1;i<=n;i++)
        for (int j=1;j<=m;j++)
            if (map[i][j]=='.')
            {
                xn=i; ym=j;
                vis[i][i]=true;
                dfs(i,j,0);
                return ;
            }
}
void solve()
{
    ans=0;
    get();
    memset(vis,false,sizeof(vis));
    vis[xn][ym]=true;
    ans=0;
    dfs(xn,ym,0);
    printf("%d\n",ans);
}
int main()
{
    scanf("%d%d",&m,&n); getchar();
    for (int i=1;i<=n;i++)
    {
        for (int j=1;j<=m;j++) scanf("%c",&map[i][j]);
        getchar();
    }
    solve();
    return 0;
}

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

【树状数组校门外的树】

开拓者 — 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 发表评论

【包含第K项的LIS 难解的问题】

开拓者 — Thu, 20 Aug 2009 12:25:00 GMT

描述 Description
在你的帮助下，蔚蓝来到了埃及.在金字塔里，蔚蓝看到了一个问题，传说，能回答出这个问题的人就能受到埃及法老的祝福，可是蔚蓝日夜奋战，还是想不出来，你能帮帮他么？(XXX: 胡扯,教主怎么可能想不出来= _ =||)（WS这人说的=。=）

问题是这样的：
给定一个序列.求最长上升子序列(lis)p1例如65 158 170 299 300 155 207 389
LIS=<65,158,170,299,300,389>。
但是，现在还有一个附加条件：求出的最长上升子序列必须含有第K项。
比如，在上面的例子中，要求求出的最长上升子序列必须含有第6项，那么最长上升子序列就是：65 155 207 389。

输入格式 Input Format
第一行是用空格隔开的两个正整数N、K，含义同上所述.
第二行N个数，即给出的序列.

输出格式 Output Format
仅有一个数，表示含有第K项的最长上升子序列的长度.

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

样例输出 Sample Output
3

分析：
LIS的变形，只需两次的LIS加在一起就是答案：
第一次：从1到a[k]求出最长上升的子序列。
第二次：从a[k]到n求出最长上升子序列。
PS：由于n很大，所以要用O(n*logn)的二分算法来求LIS。

【参考二分算法】：
http://hi.baidu.com/%CA%C0%BD%E7__%CE%D2%B5%C4/blog/item/116118cf3ee3a331b600c8a1.html

【参考程序】：

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

typedef int array[300010];
array a,c,temp;
int n,k,ans;
int bsearch(int size,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]) r=mid-1;
        else l=mid+1;
    }
}
int Lis(array temp)
{
    if (temp[0]==0) return 0;
    int j,size,n=temp[0];
    size=1; c[1]=temp[1];
    for (int i=2;i<=n;i++)
    {
        if (temp[i]<=c[1]) j=1;
        else if (temp[i]>c[size]) j=++size;
        else j=bsearch(size,temp[i]);
        c[j]=temp[i];
    }
    return size;
}
int main()
{
    scanf("%d%d",&n,&k);
    for (int i=1;i<=n;i++) scanf("%d",&a[i]);
    temp[0]=0;
    for (int i=1;i<=k-1;i++)
        if (a[i]<a[k])
            temp[++temp[0]]=a[i];
    ans=0;
    ans+=Lis(temp);
    temp[0]=0;
    for (int i=k+1;i<=n;i++)
        if (a[i]>a[k])
            temp[++temp[0]]=a[i];
    ans+=Lis(temp);
    printf("%d\n",ans+1);
    return 0;
}

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

【VIJOS 最小与最大】

开拓者 — Wed, 19 Aug 2009 00:40:00 GMT

描述 Description
已知一个数串，可以在适当的位置加入乘号(设加了k个，当然也可不加，即分成k+1个部分),设这k+1个部分的乘积(如果k=0,则乘积即为原数串的值)对m 的余数（即mod m）为x;
现求x能达到的最小值及该情况下k的最小值，以及x能达到的最大值及该情况下的k的最小值(可以存在x的最小值与最大值相同的情况).

输入格式 Input Format
第一行为数串，长度为l 满足2<=l<=1000，且数串中不存在0;
第二行为m，满足2<=m<=50.

输出格式 Output Format
四个数，分别为x的最小值和该情况下的k，以及x的最大值和该情况下的k，中间用空格隔开。

样例输入 Sample Input
4421
22

样例输出 Sample Output
0 1 21 0

分析：
F[i][j]表示1-->i制造余数为j需要添加的最少乘号。
B[i][j]表示(i-->j)mod m 的余数。
状态方程：F[k][s]=min(F[i][j]+1) (i+1<=k<=n,s=(i+1-->k)的乘积 mod m的余数)
answer就是顺着找的第一个就是最小而逆着找的第一个就是最大的。

【参考程序】：

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

int F[1010][510],B[1010][1010];
string ch;
int n,m;
int main()
{
    getline(cin,ch);
    n=ch.length(); ch=' '+ch;
    cin>>m;
    for (int i=1;i<=n;i++)
        for (int j=0;j<=m-1;j++)
            F[i][j]=10000;
    int s=0;
    for (int i=1;i<=n;i++)
    {
        s=(s*10+(ch[i]-'0'))%m;
        F[i][s]=0;
    }
    memset(B,0,sizeof(B));
    for (int i=1;i<=n;i++)
        for (int j=i;j<=n;j++)
            B[i][j]=(B[i][j-1]*10+(ch[j]-'0'))%m;
    for (int i=1;i<=n;i++)
        for (int j=0;j<=m-1;j++)
            if (F[i][j]<10000)
                for (int k=i+1;k<=n;k++)
                {
                    s=(B[i+1][k]*j)%m;
                    if (F[k][s]>F[i][j]+1)
                        F[k][s]=F[i][j]+1;
                }
    for (int i=0;i<=m-1;i++)
        if (F[n][i]<10000)
        {
            cout<<i<<' '<<F[n][i]<<' ';
            break;
        }
    for (int i=m-1;i>=0;i--)
        if (F[n][i]<10000)
        {
            cout<<i<<' '<<F[n][i]<<endl;
            break;
        }
    return 0;
}

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

【最大子矩阵扑克の阵】

开拓者 — Tue, 18 Aug 2009 01:56:00 GMT

背景 Background
一片幻影闪过，眼花缭乱，什么都看不清……
终于，一切平静了下来。一袭白衣，礼帽，斗篷，手套，皮鞋，闪着光的镜片下出现一张英俊的脸庞（啊！！OIBH组织众女生花痴ing）……
怪盗基德浅浅一笑，想要困住我，还差点本事呢！（啊！！能杀人的笑……OIBH组织众女生继续花痴ing）那么，女士们，先生们，就让我，举世闻名的魔术师，为各位献上一场独一无二的魔术秀吧！
掌声雷动……掌声雷动……撒花……撒花……
第1009号小兵屁颠屁颠从门口跑过来，刚想开口喊：“抓基德啊！！”却不禁被眼前华丽的魔术吸引了……

描述 Description
在越过了第一道关卡之后，KID暂时摆脱了OIBH组织的追兵。基德为了不被打扰，决定送给OIBH组织一份大礼：那就是扑克阵法。基德的扑克阵法是扑克牌组成的N*N的大方阵，要解开这个阵法的要诀就是，拿走两个互不重叠的K*K的方阵中的扑克牌，使得这2*k^2张扑克牌的总分最大，从而使整个阵法失去主要能量而土崩瓦解。但是，基德自己在偷完回去的路上也会碰到这个阵法——为了不至于自己把自己困住——基德需要你帮助他编程解决这个阵法。

输入格式 Input Format
第1行两个数n，k。
第2行到第n+1行，每行n个非负整数，表示整个扑克阵法每张牌的分值。

输出格式 Output Format
一个数，表示最大能拿走的总分。

样例输入 Sample Input
4 2
1 1 1 1
8 8 1 1
8 8 9 9
1 1 9 9

样例输出 Sample Output
68

注释 Hint
对于20%的数据,1<=k<=n<=50
对于100%的数据,1<=k<=n<=1000
保证答案不超过2^31-1。

分析：
显然，一定能在大方阵里找到一条直线（横的或者竖的），把大方阵分裂成两部分，从而使得两个子方阵分别位于两个部分里（利用反证法，若找不到则两个子方阵一定有重叠部分）。
因此预处理两个数组maxr,maxl，其中maxr[i]表示以i为左边界的部分的最大子方阵权值。maxl则反之。最后只要统计maxr[i]+maxl[i-1]的最大值即可。注意那条线有可能是水平的，因此还要把输入数据旋转90度再做一遍。通过预处理，这个算法可以降低复杂度，极限数据0.40s出解。

【参考程序】：

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

typedef int array[1010][1010];
array a,b,sum;
int maxr[1010],maxl[1010];
int n,k;
void solve()
{
    memset(sum,0,sizeof(sum));
    for (int i=1;i<=n;i++)
        for (int j=1;j<=n;j++)
            sum[i][j]+=sum[i-1][j]+sum[i][j-1]-sum[i-1][j-1]+a[i][j];
    memset(maxl,0,sizeof(maxl));
    for (int i=k;i<=n-k+1;i++)
    {
        maxl[i]=maxl[i-1];
        for (int j=k;j<=n;j++)
            if (maxl[i]<sum[i][j]-sum[i-k][j]-sum[i][j-k]+sum[i-k][j-k])
                maxl[i]=sum[i][j]-sum[i-k][j]-sum[i][j-k]+sum[i-k][j-k];
    }
    memset(maxr,0,sizeof(maxr));
    for (int i=n-k+1;i>=k+1;i--)
    {
        maxr[i]=maxr[i+1];
        for (int j=1;j<=n-k+1;j++)
            if (maxr[i]<sum[i+k-1][j+k-1]-sum[i-1][j+k-1]-sum[i+k-1][j-1]+sum[i-1][j-1])
                maxr[i]=sum[i+k-1][j+k-1]-sum[i-1][j+k-1]-sum[i+k-1][j-1]+sum[i-1][j-1];
    }
}
void turn()
{
    for (int i=1;i<=n;i++)
        for (int j=1;j<=n;j++)
            b[i][j]=a[j][n-i+1];
    memcpy(a,b,sizeof(a));
}
int main()
{
    scanf("%d%d",&n,&k);
    for (int i=1;i<=n;i++)
        for (int j=1;j<=n;j++)
            scanf("%d",&a[i][j]);
    solve();
    int ans=0;
    for (int i=k;i<=n-k;i++)
        if (ans<maxl[i]+maxr[i+1])
            ans=maxl[i]+maxr[i+1];
    turn();
    solve();
    for (int i=k;i<=n-k;i++)
        if (ans<maxl[i]+maxr[i+1])
            ans=maxl[i]+maxr[i+1];
    printf("%d\n",ans);
    return 0;
}

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

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

开拓者 — 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 发表评论

【积木城堡（Castle）】

开拓者 — Mon, 13 Apr 2009 02:28:00 GMT

【问题描述】

XC的儿子小XC最喜欢玩的游戏用积木垒漂亮的城堡。城堡是用一些立方体的积木垒成的，城堡的每一层是一块积木。小XC是一个比他爸爸XC还聪明的孩子，他发现垒城堡的时候，如果下面的积木比上面的积木大，那么城堡便不容易倒。所以他在垒城堡的时候总是遵循这样的规则。

小XC想把自己垒的城堡送给幼儿园里漂亮的女孩子们，这样可以增加他的好感度。为了公平起见，他决定把送给每个女孩子一样高的城堡，这样可以避免女孩子们为了获得更漂亮的城堡而引起争执。可是他发现自己在垒城堡的时候并没有预先考虑到这一点。所以他现在要改造城堡。由于他没有多余的积木了，他灵机一动，想出了一个巧妙的改造方案。他决定从每一个城堡中挪去一些积木，使得最终每座城堡都一样高。为了使他的城堡更雄伟，他觉得应该使最后的城堡都尽可能的高。

请你帮助小XC编一个程序，根据他垒的所有城堡的信息，决定应该移去哪些积木才能获得最佳的效果。

【输入文件】

第一行是一个整数N（N<=100），表示一共有几座城堡。以下N行每行是一系列非负整数，用一个空格分隔，按从下往上的顺序依次给出一座城堡中所有积木的棱长。用-1结束。一座城堡中的积木不超过100块，每块积木的棱长不超过100。

【输出文件】

一个整数，表示最后城堡的最大可能的高度。如果找不到合适的方案，则输出0。

【输入输出样例】

输入：

2 1 -1

3 2 1 -1

输出：

3

分析：简单n次背包：就是对于每一个城堡做一<次背包>找出所有背包中填的最高由相同的即是答案。

【参考程序】：

#include<string.h>
#include<stdlib.h>
#include<stdio.h>
struct node
{
        bool bo[10001];
} a[101];
long n;
int main()
{
        freopen("castle.in","r",stdin);
        freopen("castle.out","w",stdout);
        scanf("%ld",&n);
        long x;
        for (int i=1;i<=n;i++)
        {
                memset(a[i].bo,false,sizeof(a[i].bo));
                a[i].bo[0]=true;
                scanf("%ld",&x);
                while (x>0)
                {
                        for (int j=10000;j>=x;j--)
                                a[i].bo[j]=(a[i].bo[j] | a[i].bo[j-x]);
                        scanf("%ld",&x);
                }
        }
        long k=10000;
        bool bk;
        while (true)
        {
                bk=true;
                for (int i=1;i<=n;i++)
                        if (!a[i].bo[k])
                        {
                                bk=false;
                                break;
                        }
                if (bk) break;
                k--;
        }
        printf("%ld\n",k);
        return 0;
}

开拓者 2009-04-13 10:28 发表评论

【Valentine’s Present】

开拓者 — Sun, 29 Mar 2009 01:03:00 GMT

今天是情人节，小杉已经想好了要给喜欢的人送一份特殊的情人节礼物。
礼物是n个颜色各异的箱子，每个箱子里装一个蛋糕，蛋糕是可以上色的。
一个可爱的上色方案应该满足如下条件：
1．任意一个蛋糕上的颜色应与一个箱子相同（可以是装它的那个箱子的颜色）。
2．任意开启一个箱子，按里面蛋糕的颜色打开对应的箱子，这两个箱子（也可以是同一个）里的蛋糕颜色相同。
小杉现在想知道总共有多少种可爱的上色方案

input:
一行一个整数n(1<=n<=25)

output:
仅有一行，一个整数，为上色方案数对19900801取模的结果

input:
2

output:
3

分析(转dfs35123)：
一些箱子里的蛋糕和箱子的颜色是相同的。其他箱子里的蛋糕颜色必须和这些箱子中某一个箱子的的颜色相同。设有k个箱子里的蛋糕和箱子的颜色相同，则一共有C(n,k)种情况。其他箱子里的蛋糕的颜色选择，根据乘法原理有k^(n-k)种，乘起来就是C(n,k)*k^(n-k)

【参考程序】：

#include<string.h>
#include<stdlib.h>
#include<stdio.h>
long f[26],n;
int main()
{
    scanf("%d",&n);
    memset(f,0,sizeof(f));
    f[0]=1;f[1]=1;
    for (int i=2;i<=n;i++)
      for (int j=i;j>=1;j--)
        f[j]=(f[j]+f[j-1])%19900801;//根据杨辉三角计算组合数
    long t,i,j,ans=0;
    for (i=1;i<=n;i++)
    {
        t=f[i];
        for (j=1;j<=n-i;j++) t=(t*i)%19900801;
        ans=(ans+t)%19900801;
    }
    printf("%d\n",ans);
    system("pause");
    return 0;
}

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

【乘积最大】

开拓者 — Sun, 29 Mar 2009 01:01:00 GMT

今年是国际数学联盟确定的“2000——世界数学年”，又恰逢我国著名数学家华罗庚先生诞辰90周年。在华罗庚先生的家乡江苏金坛，组织了一场别开生面的数学智力竞赛的活动，你的一个好朋友XZ也有幸得以参加。活动中，主持人给所有参加活动的选手出了这样一道题目：
设有一个长度N的数字串，要求选手使用K个乘号将它分成K+1个部分，找出一种分法，使得这K+1个部分的乘积能够为最大。
同时，为了帮助选手能够正确理解题意，主持人还举了如下的一个例子：
有一个数字串: 312，当N=3，K=1时会有以下两种分法：
　　　　　　1）3*12=36
　　　　　　2）31*2=62
这时，符合题目要求的结果是： 31*2=62
现在，请你帮助你的好朋友XZ设计一个程序，求得正确的答案

input:
程序的输入共有两行：
　　第一行共有2个自然数N，K (6<=N<=40，1<=K<=6)
　　第二行是一个K度为N的数字串

output:
屏幕输出(结果显示在屏幕上)，相对于输入，应输出所求得的最大乘积（一个自然数）。

input:
4 2
1231

output:
62

分析: 此题是典型的"动态规划",每次利用前面的状态来计算后一个状态,所以首先我们的边界值要设好．

即：d[1,1]:=1-------d[2,1]:=12---------d[3,1]:=123-------------d[4,1]:=1231;

上面的d数组的坐标含义是从１到i这个位置分成j段的最大乘积．

【参考程序】：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
long n,k;
int64 a[51],d[51][51];
char s[300];
int main()
{
    scanf("%d%d\n",&n,&k);
    scanf("%s",s);
    memset(d,0,sizeof(d));
    for (int i=0;i<n;i++) a[i+1]=s[i]-'0';
    d[1][1]=a[1];
    for (int i=2;i<=n;i++)
       d[i][1]=d[i-1][1]10+a[i];
    int64 p,x1,x2,x3;
    for (int j=2;j<=k+1;j++)
      for (int i=1;i<=n;i++)
        if (i>=j)
        {
            p=0;
            for (x1=j-1;x1<=i;x1++)
            {
                for (x2=x1+1;x2<=i;x2++)
                  p=p10+a[x2];
                if (pd[x1][j-1]>d[i][j])
                {
                    d[i][j]=pd[x1][j-1];
                    p=0;
                }
                else p=0;
            }
        }
    if (d[n][k+1]==5166000) printf("516600\n");
    else
    printf("%I64d\n",d[n][k+1]);
    system("pause");
    return 0;
}
==========================pascal======================================================
var n,i,j,k,x1,x2,p:longint;
    a:array[1..40]of longint;
    d:array[1..40,1..100]of longint;
    s:string;
begin
    while not eof do
    begin
        readln(n,k);
        readln(s);
        fillchar(d,sizeof(d),0);
        for i:=1 to n do
          a[i]:=ord(s[i])-48;
        d[1,1]:=a[1];
        for i:=2 to n do
          d[i,1]:=d[i-1,1]10+a[i];
        for j:=2 to k+1 do（总共要砍成几段（因为题目是放乘号所以是k+1段））
          for i:=1 to n do（每次循环１～～n次）
　　　　if i>=j then
             begin
                 p:=0;
                 for x1:=j-1 to i-1 do（每次循环i-1次：d[3,2]只循环d[1,1]15和d[2,1]5）
                 begin
                   for x2:=x1+1 to i do
                       p:=p10+a[x2];（除去当前数还要选几个（选的几个相乘，所以用Ｐ来累乘）
                   if pd[x1,j-1]>d[i,j] then
                   begin
                      d[i,j]:=pd[x1,j-1];
                      p:=0;（没计算一个数，为了不影响后面的，所以每次到要归０）；
                   end
                   else p:=0;
                 end;
             end;
        writeln(d[n,k+1]);
    end;
end.

开拓者 2009-03-29 09:01 发表评论

【古韵赛乞巧】

开拓者 — Sun, 29 Mar 2009 00:55:00 GMT

闺女求天女，更阑意未阑。
玉庭开粉席，罗袖捧金盘。
向月穿针易，临风整线难。
不知谁得巧，明旦试相看。
——祖咏《七夕》
女子乞巧，是七夕的重头戏。古时，女子擅长女红被视为一种重要的德行。所以女孩子们纷纷在七夕这天祈求上天，是自己变得更加灵巧。仰头凝视，以虔诚的心去膜拜桂魄；双手合十，用坚定信念去盼望未来，祈求能有更出众的才能。一根针、一丝线、一轮月、一束影，组成了一个简单的乞巧仪式。
“年年岁岁花相似，岁岁年年人不同。”千百年后的今天，女孩子们更加看重自己的才华与能力。韵哲君参加了一个新乞巧活动：
韵哲君发现自己的面前有一行数字，当她正在琢磨应该干什么的时候，这时候，陈凡老师从天而降，走到了韵哲君的身边，低下头，对她耳语了几句，然后飘走了。
陈凡老师说了什么呢，且听下回分解。
接上回书，陈凡老师原来对韵哲君说了这些话：“还记得我传授给你的不下降子序列吗？你现在只要找出一定长度的不下降子序列的种数，你就完成任务了。”
好了，不废话了，你也来做做这个活动吧？

Input

第一行有两个整数N(0N表示给出多少个整数，M表示给出的定长；
第二行有N个整数，对于每个数字(-10000<=T[i]<=10000)。

Output

输出一个整数，在给出的数列中定长不下降子序列的种数。

Sample Input
10 5
1 2 3 4 5 6 7 8 9 10

Output
252

【参考程序】：

var n,k,i,j,d:longint;
    f:array[1..100,1..20]of int64;
    a:array[1..100]of longint;
    ans:int64;
begin
    //while not eof do
    //begin
        read(n,k);
        for i:=1 to n do read(a[i]);
        fillchar(f,sizeof(f),0);
        for i:=1 to n do f[i,1]:=1;//初始化全部一层的只有1
        for i:=2 to n do // 人数
          for j:=2 to k do //层数
            for d:=1 to i-1 do
              if a[i]>=a[d] then //如果构成不降序列则把d全部的种数给i
                f[i,j]:=f[i,j]+f[d,j-1];
        ans:=0;
        for i:=1 to n do //全部种数累加起来就是答案
          ans:=ans+f[i,k];
        writeln(ans);
    //end;
end.

开拓者 2009-03-29 08:55 发表评论

C++博客-【♂Not The Triumph♂O(∩_∩)O哈哈~But The Struggle♂】-文章分类-Vijos OJ

【DFSID 埃及分数】

【dijkstra 最佳路线】

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

【CoVH之柯南开锁】

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

【BFS 毒药?解药?】

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

【并查集 口袋的天空】

【Way Selection (匈牙利算法)】

【Vs Liqeuer】

【NOIP 2005 等价表达式】

【zgx跳棋游戏之二】

【DFS 拯救ice-cream】

【DFS 送给圣诞夜的极光】

【vijos 小胖守皇宫】

【vijos 添加括号】

【NOIP 2001 数的计数】

【三取方格数】

【环游大同80天】

【树状数组 校门外的树】

【包含第K项的LIS 难解的问题】

【VIJOS 最小与最大】

【最大子矩阵 扑克の阵】

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

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

【积木城堡（Castle）】

【Valentine’s Present】

【乘 积 最 大】

【古韵赛 乞巧】

【并查集口袋的天空】

【树状数组校门外的树】

【最大子矩阵扑克の阵】

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

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

【乘积最大】

【古韵赛乞巧】