C++博客-【♂Not The Triumph♂O(∩_∩)O哈哈~But The Struggle♂】-文章分类-动态规划&背包

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

【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 2006 开心的金明】

开拓者 — Sat, 22 Aug 2009 09:10:00 GMT

Description
金明今天很开心，家里购置的新房就要领钥匙了，新房里有一间他自己专用的很宽敞的房间。更让他高兴的是，妈妈昨天对他说：“你的房间需要购买哪些物品，怎么布置，你说了算，只要不超过N元钱就行”。今天一早金明就开始做预算，但是他想买的东西太多了，肯定会超过妈妈限定的N元。于是，他把每件物品规定了一个重要度，分为5等：用整数1~5表示，第5等最重要。他还从因特网上查到了每件物品的价格（都是整数元）。他希望在不超过N元（可以等于N元）的前提下，使每件物品的价格与重要度的乘积的总和最大。
设第j件物品的价格为v[j]，重要度为w[j]，共选中了k件物品，编号依次为j1，j2，……，jk，则所求的总和为：
v[j1]*w[j1]+v[j2]*w[j2]+ …+v[jk]*w[jk]。（其中*为乘号）
请你帮助金明设计一个满足要求的购物单。

Input
输入文件happy.in 的第1行，为两个正整数，用一个空格隔开：N m(其中N（<30000）表示总钱数，m（<25）为希望购买物品的个数。)
从第2行到第m+1行，第j行给出了编号为j-1的物品的基本数据，每行有2个非负整数v p(其中v表示该物品的价格(v<=10000)，p表示该物品的重要度(1~5))

Output
输出文件happy.out只有一个正整数，为不超过总钱数的物品的价格与重要度乘积的总和的最大值(<100000000)。

Sample Input
1000 5
800 2
400 5
300 5
400 3
200 2

Sample Output
3900

【参考程序】：

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

long long f[30010];
int n,m;
int main()
{
    scanf("%d%d",&n,&m);
    memset(f,0,sizeof(f));
    for (int i=0;i<=n;i++) f[i]=0;
    int w,v;
    for (int i=1;i<=m;i++)
    {
        scanf("%d%d",&w,&v);
        for (int j=n;j>=w;j--)
            if (f[j]<f[j-w]+w*v)
                f[j]=f[j-w]+w*v;
    }
    printf("%lld\n",f[n]);
    return 0;
}

开拓者 2009-08-22 17:10 发表评论

【NOIP 2006 金明的预算方案】

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

金明今天很开心，家里购置的新房就要领钥匙了，新房里有一间金明自己专用的很宽敞的房间。更让他高兴的是，妈妈昨天对他说：“你的房间需要购买哪些物品，怎么布置，你说了算，只要不超过N元钱就行”。今天一早，金明就开始做预算了，他把想买的物品分为两类：主件与附件，附件是从属于某个主件的，下表就是一些主件与附件的例子：
主件附件
电脑打印机，扫描仪
书柜图书
书桌台灯，文具
工作椅无
　如果要买归类为附件的物品，必须先买该附件所属的主件。每个主件可以有0个、1个或2个附件。附件不再有从属于自己的附件。金明想买的东西很多，肯定会超过妈妈限定的N元。于是，他把每件物品规定了一个重要度，分为5等：用整数1~5表示，第5等最重要。他还从因特网上查到了每件物品的价格（都是10元的整数倍）。他希望在不超过N元（可以等于N元）的前提下，使每件物品的价格与重要度的乘积的总和最大。

　　设第j件物品的价格为v[j]，重要度为w[j]，共选中了k件物品，编号依次为j1，j2，……，jk，则所求的总和为：v[j1]*w[j1]+v[j2]*w[j2]+ …+v[jk]*w[jk]。（其中*为乘号）请你帮助金明设计一个满足要求的购物单。

input：
输入文件的第1行，为两个正整数，用一个空格隔开：N m
其中N（<32000）表示总钱数，m（<60）为希望购买物品的个数。）
从第2行到第m+1行，第j行给出了编号为j-1的物品的基本数据，每行有3个非负整数v p q
(其中v表示该物品的价格(v<10000)，p表示该物品的重要度(1~5)，q表示该物品是主件还是附件。如果q=0，表示该物品为主件，如果q>0，表示该物品为附件，q是所属主件的编号)

output：
输出文件只有一个正整数，为不超过总钱数的物品的价格与重要度乘积的总和的最大值(<200000)。

【参考程序】：

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

struct node
{
    int x;
    int v[5],w[5];
} a[70];
int f[100][4000];
int n,m,k;
void dp()
{
    memset(f,0,sizeof(f));
    for (int i=1;i<=m;i++)
        for (int j=1;j<=n;j++)
        {
            f[i][j]=f[i-1][j];
            if (j-a[i].v[0]>=0)
            {
                if (f[i][j]<f[i-1][j-a[i].v[0]]+a[i].w[0])
                    f[i][j]=f[i-1][j-a[i].v[0]]+a[i].w[0];
            }
            if (j-a[i].v[0]-a[i].v[1]>=0)
            {
                if (f[i][j]<f[i-1][j-a[i].v[0]-a[i].v[1]]+a[i].w[0]+a[i].w[1])
                    f[i][j]=f[i-1][j-a[i].v[0]-a[i].v[1]]+a[i].w[0]+a[i].w[1];
            }
            if (j-a[i].v[0]-a[i].v[2]>=0)
            {
                if (f[i][j]<f[i-1][j-a[i].v[0]-a[i].v[2]]+a[i].w[0]+a[i].w[2])
                    f[i][j]=f[i-1][j-a[i].v[0]-a[i].v[2]]+a[i].w[0]+a[i].w[2];
            }
            if (j-a[i].v[0]-a[i].v[1]-a[i].v[2]>=0)
            {
                if (f[i][j]<f[i-1][j-a[i].v[0]-a[i].v[1]-a[i].v[2]]+a[i].w[0]+a[i].w[1]+a[i].w[2])
                    f[i][j]=f[i-1][j-a[i].v[0]-a[i].v[1]-a[i].v[2]]+a[i].w[0]+a[i].w[1]+a[i].w[2];
            }
        }
}
int main()
{
    for (int i=1;i<=m;i++) a[i].x=0;
    scanf("%d%d",&n,&m);
    n/=10;
    int v1,p1,q1;
    for (int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&v1,&p1,&q1);
        v1/=10;
        if (q1==0)
        {
            a[i].v[0]=v1; a[i].w[0]=p1*v1;
        }
        else
        {
            a[q1].x++;
            a[q1].v[a[q1].x]=v1;
            a[q1].w[a[q1].x]=p1*v1;
        }
    }
    dp();
    printf("%d\n",f[m][n]*10);
    return 0;
}

【参考程序】：//pascal

type tt=record
     money,jia,zong:longint;
    end;
var b:array[1..100] of longint;
    a:array[1..100,1..3] of tt;
    f:array[0..100,0..4000] of longint;
    i,j,n,m,c,x,z:longint;
function findmax(a,b,c,d,e:integer):integer;
var max:longint;
begin
   max:=a;
   if b>max then max:=b;
   if c>max then max:=c;
   if d>max then max:=d;
   if e>max then max:=e;
   findmax:=max;
end;
procedure dp;
var i,j,max1,max2,max3,max4,max:longint;
begin
   for i:=1 to m do
     for j:=1 to n do
     begin
        max1:=0;max2:=0;max3:=0;max4:=0;
        max:=f[i-1,j];
        if (j-a[i,1].money)>=0 then
           max1:=f[i-1,j-a[i,1].money]+a[i,1].zong;
        if (j-a[i,1].money-a[i,2].money)>=0 then
           max2:=f[i-1,j-a[i,1].money-a[i,2].money]+a[i,1].zong+a[i,2].zong;
        if (j-a[i,1].money-a[i,3].money)>=0 then
           max3:=f[i-1,j-a[i,1].money-a[i,3].money]+a[i,1].zong+a[i,3].zong;
        if (j-a[i,1].money-a[i,2].money-a[i,3].money)>=0 then
           max4:=f[i-1,j-a[i,1].money-a[i,2].money-a[i,3].money]+a[i,1].zong+a[i,2].zong+a[i,3].zong;
        f[i,j]:=findmax(max1,max2,max3,max4,max);
     end;
end;
begin
   //while not eof do
   //begin
    readln(n,m);
    n:=n div 10;
    for i:=1 to 60 do
      for j:=1 to 3 do
      begin
         a[i,j].money:=0;
         a[i,j].jia:=0;
         a[i,j].zong:=0;
      end;
    for i:=1 to m do b[i]:=1;
    fillchar(f,sizeof(f),0);
    for i:=1 to m do
    begin
        readln(z,x,c);
        z:=z div 10;
        if c=0 then
        begin
            a[i,1].money:=z;
            a[i,1].jia:=x;
            a[i,1].zong:=z*x;
        end
        else
        begin
            a[c,b[c]+1].money:=z;
            a[c,b[c]+1].jia:=x;
            a[c,b[c]+1].zong:=z*x;
            inc(b[c]);
        end;
    end;
    dp;
    writeln(f[m,n]*10);
   //end;
end.

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

【NOIP 2008 传纸条】

开拓者 — Sat, 22 Aug 2009 02:51:00 GMT

Description
小渊和小轩是好朋友也是同班同学，他们在一起总有谈不完的话题。一次素质拓展活动中，班上同学安排做成一个m行n列的矩阵，而小渊和小轩被安排在矩阵对角线的两端，因此，他们就无法直接交谈了。幸运的是，他们可以通过传纸条来进行交流。纸条要经由许多同学传到对方手里，小渊坐在矩阵的左上角，坐标 (1,1)，小轩坐在矩阵的右下角，坐标(m,n)。从小渊传到小轩的纸条只可以向下或者向右传递，从小轩传给小渊的纸条只可以向上或者向左传递。
　在活动进行中，小渊希望给小轩传递一张纸条，同时希望小轩给他回复。班里每个同学都可以帮他们传递，但只会帮他们一次，也就是说如果此人在小渊递给小轩纸条的时候帮忙，那么在小轩递给小渊的时候就不会再帮忙。反之亦然。
　还有一件事情需要注意，全班每个同学愿意帮忙的好感度有高有低（注意：小渊和小轩的好心程度没有定义，输入时用0表示），可以用一个 0-100的自然数来表示，数越大表示越好心。小渊和小轩希望尽可能找好心程度高的同学来帮忙传纸条，即找到来回两条传递路径，使得这两条路径上同学的好心程度只和最大。现在，请你帮助小渊和小轩找到这样的两条路径。

Input
输入文件message.in的第一行有2个用空格隔开的整数m和n，表示班里有m行n列（1 < m,n <= 50）。
接下来的m行是一个m*n的矩阵，矩阵中第i行j列的整数表示坐在第i行j列的学生的好心程度。每行的n个整数之间用空格隔开。

Output
输出文件message.out共一行，包含一个整数，表示来回两条路上参与传递纸条的学生的好心程度之和的最大值。

Sample Input
3 3
0 3 9
2 8 5
5 7 0

Sample Output
34

Hint
30%的数据满足：1 < m,n <= 10
100%的数据满足：1 < m,n <= 50

【参考程序】：

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

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

开拓者 2009-08-22 10:51 发表评论

【三取方格数】

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

【NOI 98 免费馅饼】

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

SERKOI最新推出了一种叫做“免费馅饼”的游戏:游戏在一个舞台上进行。舞台的宽度为W格，天幕的高度为H格，游戏者占一格。开始时游戏者站在舞台的正中央，手里拿着一个托盘。下图为天幕的高度为4格时某一个时刻游戏者接馅饼的情景。

游戏开始后，从舞台天幕顶端的格子中不断出现馅饼并垂直下落。游戏者左右移动去接馅饼。游戏者每秒可以向左或向右移动一格或两格，也可以站在原地不动。

馅饼有很多种，游戏者事先根据自己的口味，对各种馅饼依次打了分。同时，在8-308电脑的遥控下，各种馅饼下落的速度也是不一样的，下落速度以格/秒为单位。

当馅饼在某一秒末恰好到达游戏者所在的格子中，游戏者就收集到了这块馅饼。

写一个程序，帮助我们的游戏者收集馅饼，使得所收集馅饼的分数之和最大。

输入
输入文件的第一行是用空格隔开的两个正整数，分别给出了舞台的宽度W（1到99之间的奇数）和高度H（1到100之间的整数）。

接下来依馅饼的初始下落时间顺序给出了所有馅饼的信息。每一行给出了一块馅饼的信息。由四个正整数组成，分别表示了馅饼的初始下落时刻（0到1000秒），水平位置、下落速度（1到100）以及分值。游戏开始时刻为0。从1开始自左向右依次对水平方向的每格编号。

输入文件中同一行相邻两项之间用一个或多个空格隔开。

输出
输出文件的第一行给出了一个正整数，表示你的程序所收集的最大分数之和。

其后的每一行依时间顺序给出了游戏者每秒的决策。输出0表示原地不动、1或2表示向右移动一步或两步、-1 或-2表示向左移动一步或两步。输出应持续到游戏者收集完他要收集的最后一块馅饼为止。

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

样例输出
12
-1
1
1

【参考程序】：

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

int F[1010][1010],a[1010][1010],prev[1010][1010];
int n,m,ans,sumt,bx,by;
void cout_path(int bx,int by)
{
    if (bx<=0) return ;
    cout_path(bx-1,by-prev[bx][by]);
    printf("%d\n",prev[bx][by]);
}
int main()
{
    freopen("freepizza.in","r",stdin);
    freopen("freepizza.out","w",stdout);
    scanf("%d%d",&n,&m);
    sumt=0;
    int t,w,v,s;
    memset(a,0,sizeof(a));
    while (scanf("%d%d%d%d",&t,&w,&v,&s)!=EOF)
    {
        if ((m-1)%v==0 || t==0)
        {
            a[t+(m-1)/v][w]+=s;
            if (t+(m-1)/v>sumt) sumt=t+(m-1)/v;
        }
    }
    for (int i=0;i<=sumt;i++)
        for (int j=1;j<=m;j++)
            F[i][j]=-0x7FFFFFFF;
    ans=F[0][(n+1)/2]=a[0][(n+1)/2];
    for (int i=1;i<=sumt;i++)
        for (int j=1;j<=n;j++)
        {
            for (int k=2;k>=-2;k--)
                if (j-k>0 && j-k<=n && F[i-1][j-k]>F[i][j])
                {
                    F[i][j]=F[i-1][j-k];
                    prev[i][j]=k;
                }
            F[i][j]+=a[i][j];
            if (F[i][j]>ans)
            {
                ans=F[i][j];
                bx=i; by=j;
            }
        }
    printf("%d\n",ans);
    for (int i=1;i<=n;i++)
        if (F[sumt][i]>ans)
        {
            ans=F[sumt][i];
            bx=sumt; by=i;
        }
    if (sumt==0 && ans) printf("0\n");
    else cout_path(bx,by);
    return 0;
}

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

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

【三维最大子矩阵吃西瓜】

开拓者 — Thu, 20 Aug 2009 03:33:00 GMT

Description
【题目说明】
   此题中出现的所有数全为整数
【题目背景】
   SubRaY有一天得到一块西瓜,是长方体形的....
【题目描述】
   SubRaY发现这块西瓜长m厘米,宽n厘米,高h厘米.他发现如果把这块西瓜平均地分成m*n*h块1立方厘米的小正方体,那么每一小块都会有一个营养值(可能为负,因为西瓜是有可能坏掉的,但是绝对值不超过200).
现在SubRaY决定从这m*n*h立方厘米的西瓜中切出mm*nn*hh立方厘米的一块小西瓜(一定是立方体形,长宽高均为整数),然后吃掉它.他想知道他最多能获得多少营养值.(0<=mm<=m,0<=nn<=n,0<=hh<=h.mm,nn,hh 的值由您来决定).
换句话说,我们希望从一个m*n*h的三维矩阵中,找出一个三维子矩阵,这个子矩阵的权和最大。

Input
首行三个数h,m,n(注意顺序),分别表示西瓜的高,长,宽.以下h部分,每部分是一个m*n的矩阵,第i部分第j行的第k个数表示西瓜第i层,第j行第k列的那块1立方厘米的小正方体的营养值。

Output
SubRaY所能得到的最大营养值

Sample Input
2 3 4
4 1 2 8
0 5 -48 4
3 0 1 9
2 1 4 9
1 0 1 7
3 1 2 8

Sample Output
45

Hint
【数据范围】
对于30%的数据,h=1,1<=m,n<=10
对于全部的数据,1<=h<=32,1<=m,n<=50,保证h<=m,n。

分析：
把三维的每个高(竖的下来的那些列，不是y坐标那个列)的和存放到二维数组中，再用二维的最大子矩阵即可。(好像废话^_^)

【参考程序】：

#include<cstring>
#include<cstdio>
#include<iostream>
#define INF -25000000
using namespace std;
int sum[60][60][60],he[60][60][60],s[60][60];
int h,m,n,ans;
int Maxsum1(int *a)
{
    int sums=INF,ss=0;
    for (int i=1;i<=n;i++)
    {
        if (ss>0) ss+=a[i];
        else ss=a[i];
        if (ss>sums) sums=ss;
    }
    return sums;
}
int Maxsum2(int a[][60])
{
    int sums=INF,ss,F[60];
    for (int i=1;i<=m;i++)
    {
        memset(F,0,sizeof(F));
        for (int j=i;j<=m;j++)
        {
            for (int k=1;k<=n;k++) F[k]+=a[j][k];
            /*ss=0;
            for (int k=1;k<=n;k++)
                if (ss>0) ss+=F[k];
                else ss=F[k];*/
            ss=Maxsum1(F);
            if (ss>sums) sums=ss;
        }
    }
    return sums;
}
int Maxsum3()
{
    int sums=INF,ss;
    for (int i=1;i<=h;i++)
        for (int j=i;j<=h;j++)
        {
            for (int i1=1;i1<=m;i1++)
                for (int j1=1;j1<=n;j1++)
                    s[i1][j1]=sum[j][i1][j1]-sum[i-1][i1][j1];
            ss=Maxsum2(s);
            if (sums<ss) sums=ss;
        }
    return sums;
}
int main()
{
    scanf("%d%d%d",&h,&m,&n);
    for (int i=1;i<=h;i++)
        for (int j=1;j<=m;j++)
            for (int k=1;k<=n;k++)
                scanf("%d",&he[i][j][k]);
    for (int i=1;i<=m;i++)
        for (int j=1;j<=n;j++)
            sum[1][i][j]=he[1][i][j];
    for (int i=2;i<=h;i++)
        for (int j=1;j<=m;j++)
            for (int k=1;k<=n;k++)
                sum[i][j][k]=sum[i-1][j][k]+he[i][j][k];
    ans=Maxsum3();
    printf("%d\n",ans);
    return 0;
}

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

【巴蜀 OJ 创意吃鱼法】

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

猫猫把鱼全部转移到了她那长方形大池子中，然后开始思考：到底要以何种方法吃鱼呢(猫猫就是这么可爱，吃鱼也要想好吃法 ^_*）。她发现，把大池子视为01矩阵（0表示对应位置无鱼，1表示对应位置有鱼)有助于决定吃鱼策略。在代表池子的01矩阵中，有很多的正方形子矩阵，如果某个正方形子矩阵的某条对角线上都有鱼，且此正方形子矩阵的其他地方无鱼，猫猫就可以从这个正方形子矩阵“对角线的一端”下口，只一吸，就能把对角线上的那一队鲜鱼吸入口中。
　猫猫是个贪婪的家伙，所以她想一口吃掉尽量多的鱼。请你帮猫猫计算一下，她一口下去，最多可以吃掉多少条鱼？

Input
有多组输入数据，每组数据：
第一行有两个整数n和m（n,m≥1），描述池塘规模。接下来的n行，每行有m个数字(非“0”即“1”)每两个数字之间用空格隔开。

Output
只有一个整数——猫猫一口下去可以吃掉的鱼的数量，占一行，行末有回车。

Sample Input
4 6
0 1 0 1 0 0
0 0 1 0 1 0
1 1 0 0 0 1
0 1 1 0 1 0

Sample Output
3

Hint
对于30%的数据，有n,m≤100
对于60%的数据，有n,m≤1000
对于100%的数据，有n,m≤2500

分析：
F[i][j]表示以(i,j)为对角顶点(map[i][j]=1)的一个正方形的对角线的最小值.
up[i][j]表示(i,j)上面(包含(i,j))连续的一段0的个数。
left[i][j]表示(i,j)左边(包含(i,j))连续的一段0的个数。
right[i][j]表示(i,j)右边(包含(i,j))连续的一段0的个数。
因为对角线有两条，所以要分左对角线和右对角线分别DP，answer=max(F[i][j])

【参考程序】：

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

typedef int array[2510][2510];
array map,up,left,right,F;
int n,m,ans;
void yuchuli()
{
    memset(up,0,sizeof(up));
    for (int i=1;i<=n;i++)
        for (int j=1;j<=m;j++)
            if (map[i][j]==0) up[i][j]=up[i-1][j]+1;
    memset(left,0,sizeof(left));
    for (int i=1;i<=n;i++)
        for (int j=1;j<=m;j++)
            if (map[i][j]==0) left[i][j]=left[i][j-1]+1;
    memset(right,0,sizeof(right));
    for (int i=1;i<=n;i++)
        for (int j=m;j>=1;j--)
            if (map[i][j]==0) right[i][j]=right[i][j+1]+1;
}
int Min(int x,int y,int z)
{
    int t=x;
    if (y<x) return y;
    if (z<x) return z;
    return t;
}
void solve()
{
    ans=0;
    memset(F,0,sizeof(F));
    for (int i=1;i<=n;i++)
        for (int j=1;j<=m;j++)
            if (map[i][j]==1)
            {
                F[i][j]=Min(F[i-1][j-1],left[i][j-1],up[i-1][j])+1;
                if (ans<F[i][j]) ans=F[i][j];
            }
    memset(F,0,sizeof(F));
    for (int i=1;i<=n;i++)
        for (int j=m;j>=1;j--)
            if (map[i][j]==1)
            {
                F[i][j]=Min(F[i-1][j+1],up[i-1][j],right[i][j+1])+1;
                if (ans<F[i][j]) ans=F[i][j];
            }
}
int main()
{
    scanf("%d%d",&n,&m);
    for (int i=1;i<=n;i++)
        for (int j=1;j<=m;j++)
            scanf("%d",&map[i][j]);
    yuchuli();
    solve();
    printf("%d\n",ans);
    return 0;
}

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

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

【HNOI 97 凸多边形划分】

开拓者 — Mon, 17 Aug 2009 11:30:00 GMT

Description
给定一个具有n(n<=50)个顶点(从1到n编号)的凸多边形，每个顶点的权均已知。问如何把这个凸多边形划分成n-2个互不相交的三角形，使得这些三角形顶点的权的乘积之和最小？

Input
第一行为顶点数n，第二行为n个顶点（从1到n）的权值(均小于longint)。

Output
只有一行为最小的和的值。

Sample Input
5
121 122 123 245 231

Sample Output
12214884

【参考程序】：

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

typedef long long array[60];
array F[110][110],a,s1,s2,s3;
long long n;
void mark(array &c)
{
    for (int i=1;i<=c[0];i++)
    {
        c[i+1]+=c[i]/100000;
        c[i]%=100000;
    }
    while (c[c[0]+1])
    {
        c[0]++;
        c[c[0]+1]+=c[c[0]]/100000;
        c[c[0]]%=100000;
    }
}
void mul(long long a1,long long a2,long long a3,array &c)
{
    memset(c,0,sizeof(c));
    c[0]=c[1]=1;
    for (int i=1;i<=c[0];i++) c[i]*=a1;
    mark(c);
    for (int i=1;i<=c[0];i++) c[i]*=a2;
    mark(c);
    for (int i=1;i<=c[0];i++) c[i]*=a3;
    mark(c);
}
void add(array a,array b,array &c)
{
    memset(c,0,sizeof(c));
    if (a[0]>b[0]) c[0]=a[0];
    else c[0]=b[0];
    for (int i=1;i<=c[0];i++) c[i]=a[i]+b[i];
    mark(c);
}
bool check(array a,array b)
{
    if (a[0]<b[0]) return false;
    if (a[0]>b[0]) return true;
    for (int i=a[0];i>=1;i--)
        if (a[i]<b[i]) return false;
        else if (a[i]>b[i]) return true;
    return false;
}
int main()
{
    //freopen("data5.in","r",stdin);
    //freopen("data5.out","w",stdout);
    scanf("%lld",&n);
    for (int i=1;i<=n;i++) scanf("%lld",&a[i]);
    for (int i=1;i<=n;i++)
        for (int j=1;j<=n;j++)
            F[i][j][0]=1;
    for (int i=n-2;i>=1;i--)
        for (int j=i+2;j<=n;j++)
        {
            F[i][j][0]=60;
            for (int k=i+1;k<=j-1;k++)
            {
                mul(a[i],a[k],a[j],s1);
                add(F[i][k],F[k][j],s2);
                add(s1,s2,s3);
                if (check(F[i][j],s3))
                    memcpy(F[i][j],s3,sizeof(F[i][j]));
            }
        }
    printf("%lld",F[1][n][F[1][n][0]]);
    for (int i=F[1][n][0]-1;i>=1;i--) printf("%05lld",F[1][n][i]);
    printf("\n");
    return 0;
}

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

【乘积最大(加强版)】

开拓者 — Sun, 16 Aug 2009 13:04:00 GMT

Description
今年是国际数学联盟确定的“2000——世界数学年”，又恰逢我国著名数学家华罗庚先生诞辰90周年。在华罗庚先生的家乡江苏金坛，组织了一场别开生面的数学智力竞赛的活动，你的一个好朋友XZ也有幸得以参加。活动中，主持人给所有参加活动的选手出了这样
一道题目:
设有一个长度N的数字串，要求选手将它分成K个部分，找出一种分法，使得这K个部分的乘积能够为最大

同时，为了帮助选手能够正确理解题意，主持人还举了如下的一个例子：有一个数字串: 312，当N=3，K=2时会有以下两种分法：
1）3*12=36
2）31*2=62
这时，符合题目要求的结果是： 31*2=62
现在，请你帮助你的好朋友XZ设计一个程序，求得正确的答案。

Input
输入文件只有一行包含3个用空格分开的整数分别是 N，K和 N位整数。

Output
一个整数，表示讲n分成K个部分的最大乘积。

Sample Input
5 3 12345

Sample Output
2460

Hint
【样例说明】
将 12345分成 3部分，由下面6种分法：
1*2*345=690
1*23*45=1036
1*234*4=936
12*3*45=1620
12*34*5=2040
123*4*5=2460
有上面可以看出，最大乘积是最后一种分法，所以最大值是 2460
【数据范围】：
N <=100; k<=N

【参考程序】：

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

typedef int arr[110];
arr F[110][110],sum[110][110];
char s[110];
int n,k;
void getsum(int x,int y)
{
    memset(sum[x][y],0,sizeof(sum[x][y]));
    sum[x][y][0]=y-x+1;
    int len=y-x+1;
    for (int i=1;i<=len;i++)
        sum[x][y][i]=s[y-i]-'0';
}
void mul(arr a, arr b,arr &sum2)
{
    memset(sum2,0,sizeof(sum2));
    sum2[0]=a[0]+b[0]-1;
    for (int i=1;i<=a[0];i++)
        for (int j=1;j<=b[0];j++)
            sum2[i+j-1]+=a[i]*b[j];
    for (int i=1;i<=sum2[0];i++)
    {
        sum2[i+1]+=sum2[i]/10;
        sum2[i]%=10;
    }
    while (sum2[sum2[0]+1])
    {
        sum2[0]++;
        sum2[sum2[0]+1]+=sum2[sum2[0]]/10;
        sum2[sum2[0]]%=10;
    }
}
bool check(arr a,arr b)
{
    if (a[0]<b[0]) return true;
    if (a[0]>b[0]) return false;
    for (int i=a[0];i>=1;i--)
        if (a[i]<b[i]) return true;
        else if (a[i]>b[i]) return false;
    return false;
}
int main()
{
    scanf("%d%d%s",&n,&k,s);
    for (int i=1;i<=n;i++)
        for (int j=i;j<=n;j++)
            getsum(i,j);
    for (int i=0;i<=n;i++)
        for (int j=0;j<=k;j++)
            F[i][j][0]=F[i][j][1]=1;
    for (int i=1;i<=n;i++)
        for (int j=1;j<=k;j++)
            for (int l=j;l<=i;l++)
            {
                arr sum2;
                mul(F[l-1][j-1],sum[l][i],sum2);
                if (check(F[i][j],sum2))
                    memcpy(F[i][j],sum2,sizeof(F[i][j]));
            }
    int len=F[n][k][0];
    printf("%d",F[n][k][len]);
    for (int i=len-1;i>=1;i--) printf("%d",F[n][k][i]);
    printf("\n");
    return 0;
}

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

【NOIP 2005 过河】

开拓者 — Sat, 15 Aug 2009 03:30:00 GMT

【问题描述】
在河上有一座独木桥，一只青蛙想沿着独木桥从河的一侧跳到另一侧。在桥上有一些石子，青蛙很讨厌踩在这些石子上。由于桥的长度和青蛙一次跳过的距离都是正整数，我们可以把独木桥上青蛙可能到达的点看成数轴上的一串整点：0，1，……，L（其中L是桥的长度）。坐标为0的点表示桥的起点，坐标为L的点表示桥的终点。青蛙从桥的起点开始，不停的向终点方向跳跃。一次跳跃的距离是S到T之间的任意正整数（包括S,T）。当青蛙跳到或跳过坐标为L的点时，就算青蛙已经跳出了独木桥。

题目给出独木桥的长度L，青蛙跳跃的距离范围S,T，桥上石子的位置。你的任务是确定青蛙要想过河，最少需要踩到的石子数

【输入文件】
输入文件river.in的第一行有一个正整数L（1 <= L <= 109），表示独木桥的长度。第二行有三个正整数S，T，M，分别表示青蛙一次跳跃的最小距离，最大距离，及桥上石子的个数，其中1 <= S <= T <= 10，1 <= M <= 100。第三行有M个不同的正整数分别表示这M个石子在数轴上的位置（数据保证桥的起点和终点处没有石子）。所有相邻的整数之间用一个空格隔开。

【输出文件】
输出文件river.out只包括一个整数，表示青蛙过河最少需要踩到的石子数。

【样例输入】
10
2 3 5
2 3 5 6 7

【样例输出】
2

【数据规模】
对于30%的数据，L <= 10000；
对于全部的数据，L <= 10^9。

分析：
动态规划，需要状态压缩。
状态：F[i] 跳到距离i处碰到的最少的石子数。

状态转移方程：F[i]=min{ F[i-k] } + F[i] (S<=k<=T i-k>=0)
边界条件：F[i]=1 i处有石子

目标结果：min{ F[k] } (L+1<=k<=L+T-1)

状态压缩
由于L最大为10^9，直接线性递推会超时。发现石子数很少，这意味着路径上有许多很长的空白段。我们可以把长度大于S*T的空白段都缩小到S*T，这样最长只有10090了。

【参考程序】：

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

int F[10100],stone[110];
int n,m,s,t,ans;
int cmp(const void *s,const void *t)
{
    int i=*(int *)s,j=*(int *)t;
    return i-j;
}
void reduce()
{
    int p=s*t,k;
    stone[0]=0; stone[m+1]=n;
    memset(F,0,sizeof(F));
    for (int i=1;i<=m+1;i++)
    {
        if (stone[i]-stone[i-1]>p)
        {
            k=stone[i]-stone[i-1]-p;
            for (int j=i;j<=m+1;j++)
                stone[j]-=k;
            stone[i]=stone[i-1]+p;
        }
        F[stone[i]]=1;
    }
    n=stone[m+1];
}
void dp()
{
    int mins;
    for (int i=1;i<=n+t-1;i++)
    {
        mins=maxint;
        for (int j=s;j<=t;j++)
            if (i-j>=0 && F[i-j]<mins)
                mins=F[i-j];
        F[i]+=mins;
    }
}
int main()
{
    scanf("%d",&n);
    scanf("%d%d%d",&s,&t,&m);
    for (int i=1;i<=m;i++) scanf("%d",&stone[i]);
    if (s==t)
    {
        ans=0;
        for (int i=1;i<=m;i++)
            if (stone[i]%s==0) ans++;
        printf("%d\n",ans);
        exit(0);
    }
    qsort(stone+1,m,sizeof(int),cmp);
    reduce();
    dp();
    ans=maxint;
    for (int i=n+1;i<=n+t-1;i++)
        if (ans>F[i]) ans=F[i];
    printf("%d\n",ans);
    return 0;
}

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

【机器分配(HNOI 95)】

开拓者 — Thu, 13 Aug 2009 02:34:00 GMT

Description
总公司拥有高效生产设备M台，准备分给下属的N个公司。各分公司若获得这些设备，可以为国家提供一定的盈利。问：如何分配这M台设备才能使国家得到的盈利最大？求出最大盈利值。其中M <= 20，N <= 20。分配原则：每个公司有权获得任意数目的设备，但总台数不得超过总设备数M。

Input
第一行保存两个数，第一个数是设备台数M，第二个数是分公司数N。
接下来是一个N*M的矩阵，表明了第i个公司分配j台机器的盈利（都小于100）。

Output
分配这M台设备使国家所得到的盈利最大值.

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

Sample Output
7

分析：
DP解决。
F[i][j]表示前i间公司分配j台机器的最大获利，状态只和i-1有关，满足无后效性。
状态方程：F[i][j]=max(F[i-1][k]+a[i][j-k]) {0<=k<=j,a[i][j]为读入的原本获利}

【参考程序】：

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

int a[21][21],F[21][21];
int n,m;
int main()
{
    scanf("%d%d",&m,&n);
    for (int i=1;i<=n;i++)
        for (int j=1;j<=m;j++)
            scanf("%d",&a[i][j]);
    memset(F,0,sizeof(F));
    for (int i=1;i<=n;i++)
        for (int j=0;j<=m;j++)
            for (int k=0;k<=j;k++)
                if (F[i][j]<F[i-1][k]+a[i][j-k])
                    F[i][j]=F[i-1][k]+a[i][j-k];
    printf("%d\n",F[n][m]);
    return 0;
}

开拓者 2009-08-13 10:34 发表评论

【Big Barn 巨大的牛棚】

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

农夫约翰想要在他的正方形农场上建造一座正方形大牛棚。他讨厌在他的农场中砍树，想找一个能够让他在空旷无树的地方修建牛棚的地方。我们假定，他的农场划分成 N x N 的方格。输入数据中包括有树的方格的列表。你的任务是计算并输出，在他的农场中，不需要砍树却能够修建的最大正方形牛棚。牛棚的边必须和水平轴或者垂直轴平行。

格式
EXAMPLE

考虑下面的方格，它表示农夫约翰的农场，‘.'表示没有树的方格，‘#'表示有树的方格

          1 2 3 4 5 6 7 8
       1 . . . . . . . .
       2 . # . . . # . .
       3 . . . . . . . .
       4 . . . . . . . .
       5 . . . . . . . .
       6 . . # . . . . .
       7 . . . . . . . .
       8 . . . . . . . .

最大的牛棚是 5 x 5 的，可以建造在方格右下角的两个位置其中一个。

PROGRAM NAME: bigbrn
INPUT FORMAT
Line 1: 两个整数： N （1 <= N <= 1000），农场的大小，和 T （1 <= T <= 10，000）有树的方格的数量

Lines 2..T+1: 两个整数（1 <= 整数 <= N), 有树格子的横纵坐标

OUTPUT FORMAT
输出文件只由一行组成，约翰的牛棚的最大边长。

SAMPLE INPUT (file bigbrn.in)
8 3
2 2
2 6
6 3

SAMPLE OUTPUT (file bigbrn.out)
5

【参考程序】：

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

int F[1001][1001];
int N,T,ans;
int MIN(int a,int b)
{
    return a<b?a:b;
}
int MAX(int a,int b)
{
    return a>b?a:b;
}
int main()
{
    freopen("bigbrn.in","r",stdin);
    freopen("bigbrn.out","w",stdout);
    scanf("%d%d",&N,&T);
    memset(F,0,sizeof(F));
    int x,y;
    for (int i=1;i<=T;i++)
    {
        scanf("%d%d",&x,&y);
        F[x][y]=-1;
    }
    for (int i=1;i<=N;i++)
        for (int j=1;j<=N;j++)
            if (F[i][j]!=-1)
            {
                F[i][j]=1;
                F[i][j]=MAX(F[i][j],MIN(MIN(F[i-1][j-1]+1,F[i][j-1]+1),MIN(F[i-1][j-1]+1,F[i-1][j]+1)));
            }
    ans=0;
    for (int i=1;i<=N;i++)
        for (int j=1;j<=N;j++)
            if (F[i][j]>ans) ans=F[i][j];
    printf("%d\n",ans);
    return 0;
}

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

【TJU 挤牛奶】

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

描述
小卡卡终于帮农夫John找到了走丢的那一头奶牛，John为了感谢小卡卡，不仅告诉了他在Pascal山脉上可能存在Pascal圣地最大的宝藏，还说要请小卡卡喝牛奶。
可是农夫John发现他家里所储藏的牛奶已经喝光了，所以要临时给奶牛挤奶。小卡卡实在是太好心了，说要帮农夫John一起挤牛奶。John答应了，他把他的n头奶牛中的n/2头（n是个偶数）分给小卡卡挤，他自己挤剩下的n/2头奶牛。但是每一头奶牛都有不同的产奶量，农夫John为了让小卡卡减轻负担，他希望，他们两个所挤的牛奶的总量之差最小。
小卡卡得知了每头奶牛的产奶情况之后很快就解决了这个问题。

输入
该题含有多组测试数据。
每组测试数据第一行一个整数n，n为偶数且小于100。表示有n头奶牛。
第二行n个整数分别给出每头奶牛的产奶量（产奶量的总和不超过2000）。

输出
输出小卡卡和农夫所挤的牛奶量的最小差值。

样例输入
6
7 9 2 6 4 2

样例输出
0

【参考程序】：

#include<iostream>
#include<cstring>
using namespace std;
bool bag[51][1001];
int m[101],a[101];
int n;
int main()
{
    while (scanf("%d",&n)!=EOF)
    {
        int sum=0;
        for (int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            sum+=a[i];
        }
        memset(bag,false,sizeof(bag));
        bag[0][0]=true;
        memset(m,0,sizeof(m));
        for (int i=1;i<=n;i++)
            for (int j=min(i,n>>1);j>=1;j--)//最大奶牛数为n/2
                for (int k=min(m[j-1]+a[i],sum>>1);k>=a[i];k--)
                {//最大挤奶重量是sum/2
                    bag[j][k]|=bag[j-1][k-a[i]];
                    if (bag[j][k] && m[j]<k) m[j]=k;
                }//同样满足的取最能填的物品，因为可以使结果相差更小
        for (int i=sum>>1;i>=0;i--)
            if (bag[n>>1][i])
            {
                printf("%d\n",sum-(2*i));
                break;
            }
    }
    return 0;
}

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

【Buy Low Buy Lower 逢低吸纳】

开拓者 — Tue, 28 Jul 2009 11:35:00 GMT

“逢低吸纳”是炒股的一条成功秘诀。如果你想成为一个成功的投资者，就要遵守这条秘诀:

"逢低吸纳,越低越买"

这句话的意思是：每次你购买股票时的股价一定要比你上次购买时的股价低.按照这个规则购买股票的次数越多越好，看看你最多能按这个规则买几次。

给定连续的N天中每天的股价。你可以在任何一天购买一次股票，但是购买时的股价一定要比你上次购买时的股价低。写一个程序，求出最多能买几次股票。

以下面这个表为例, 某几天的股价是:

天数 1 2 3 4 5 6 7 8 9 10 11 12
股价 68 69 54 64 68 64 70 67 78 62 98 87

这个例子中, 聪明的投资者(按上面的定义)，如果每次买股票时的股价都比上一次买时低，那么他最多能买4次股票。一种买法如下(可能有其他的买法):

天数 2 5 6 10
股价 69 68 64 62

格式
PROGRAM NAME: buylow
INPUT FORMAT:(file buylow.in)

第1行: N (1 <= N <= 5000), 表示能买股票的天数。

第2行以下: N个正整数 (可能分多行) ，第i个正整数表示第i天的股价. 这些正整数大小不会超过longint(pascal)/long(c++).

OUTPUT FORMAT:(file buylow.out)

只有一行，输出两个整数：

能够买进股票的天数长度达到这个值的股票购买方案数量

在计算解的数量的时候，如果两个解所组成的字符串相同，那么这样的两个解被认为是相同的（只能算做一个解）。因此，两个不同的购买方案可能产生同一个字符串，这样只能计算一次。

SAMPLE INPUT
12
68 69 54 64 68 64 70 67
78 62 98 87

SAMPLE OUTPUT
4 2

分析：(借鉴于leokan大牛)

首先是第一个输出，求"能够买进股票的天数"也就是子序列长度啦，用O(n^2)就可以求出，很容易：

a表示读入的数据。

对于f(i)=前i个数中最长不下降子序列长度，则f(i)=max{f(1),f(2),f(3),..,f(i-1)}+1,其中被选中的f(j)满足aiai)

下界：第1个数的最长下降子序列就是它本身，则f(1)=1。

难就在第二个问题：
原话：“在计算解的数量的时候，如果两个解所组成的字符串相同，那么这样的两个解被认为是相同的（只能算做一个解）。因此，两个不同的购买方案可能产生同一个字符串，这样只能计算一次。”

也就是对于数据2 1 1 这种数据它会重复计算2 1（第一个1） 1（第二个1）。

求总数：
对于c(i)=前i个数中最长不下降子序列的个数，可以这样考虑，除去i不谈，那么之前满足最长下降子序列的c(j)=c(i)-1(因为c(j)在c(i)这个序列中，它加上i就是i的最长不下降子序列)所以得到状态转移方程：c(i)=sum(c(j)) (jai,f(i)=f(j)+1)

如何判重：
观察可能重复的发生情况，对于每一个可能重复的长度为3下降的子序列，它一定是i,j,j(i>j)这种情况，所以可以开一个boolean数组vis记录j是否出现过，若出现了，就不再计算。
最终状态转移方程：c(i)=sum(c(j)) (jai,f(i)=f(j)+1，vis[j]=false)。

最后，开个高精做加法就行了

【参考程序】：

/*
ID: XIONGNA1
PROG: buylow
LANG: C++
*/
#include<iostream>
#include<cstring>
using namespace std;
int tot[5001][101],ans[101],f[5001],a[5001];
bool vis[20001];
int n,maxans;
inline int MAX(int x,int y)
{
    return x>y?x:y;
}
void add(int *b,int *c,int *d)
{
    int cc[101];
    memset(cc,0,sizeof(cc));
    cc[0]=MAX(b[0],c[0]);
    for (int i=1;i<=cc[0];i++) cc[i]=b[i]+c[i];
    for (int i=1;i<=cc[0];i++)
    {
        cc[i+1]+=cc[i]/10;
        cc[i]%=10;
    }
    if (cc[cc[0]+1]) cc[0]++;
    memcpy(d,cc,sizeof(int)*101);
}
int main()
{
    freopen("buylow.in","r",stdin);
    freopen("buylow.out","w",stdout);
    scanf("%d",&n);
    for (int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
        f[i]=1;
    }
    maxans=1;
    for (int i=2;i<=n;i++)
    {
        for (int j=1;j<=i-1;j++)
            if (a[i]<a[j] && f[i]<f[j]+1)
                f[i]=f[j]+1;
        maxans=MAX(maxans,f[i]);
    }
    for (int i=1;i<=n;i++)
        if (f[i]==1)
        {
            memset(tot[i],0,sizeof(tot[i]));
            tot[i][0]=1;//以I结尾的不降子序列个数
            tot[i][1]=1;//高精度记录
        }
        else
        {
            memset(vis,false,sizeof(vis));
            memset(tot[i],0,sizeof(tot[i]));
            tot[i][0]=1;
            for (int j=i-1;j>=1;j--)
                if (f[j]+1==f[i] && !vis[a[j]] && a[i]<a[j])
                {
                    add(tot[i],tot[j],tot[i]);
                    vis[a[j]]=true;
                }
        }
    memset(vis,false,sizeof(vis));
    memset(ans,0,sizeof(ans));
    for (int i=n;i>=1;i--)
        if (f[i]==maxans && !vis[a[i]])
        {
            add(ans,tot[i],ans);
            vis[a[i]]=true;
        }
    printf("%d ",maxans);
    for (int i=ans[0];i>=2;i--) printf("%d",ans[i]);
    printf("%d\n",ans[1]);
    return 0;
}

开拓者 2009-07-28 19:35 发表评论

【巴蜀OJ 战略游戏】

开拓者 — Sun, 31 May 2009 12:47:00 GMT

Bob喜欢玩电脑游戏，特别是战略游戏。但是他经常无法找到快速玩过游戏的办法。现在他有个问题。他要建立一个古城堡，城堡中的路形成一棵树。他要在这棵树的结点上放置最少数目的士兵，使得这些士兵能了望到所有的路。注意，某个士兵在一个结点上时，与该结点相连的所有边将都可以被了望到。
　　请你编一程序，给定一树，帮Bob计算出他需要放置最少的士兵。

input：
输入文件中数据表示一棵树，描述如下：
　　第一行 N，表示树中结点的数目。
　　第二行至第N+1行，每行描述每个结点信息，依次为：该结点标号i，k(后面有k条边与结点I相连)，接下来k个数，分别是每条边的另一个结点标号r1，r2，...，rk。
　　对于一个n(0 < n <= 1500)个结点的树，结点标号在0到n-1之间，在输入文件中每条边只出现一次。

output：
输出文件仅包含一个数，为所求的最少的士兵数目。

input：
4
0 1 1
1 2 2 3
2 0
3 0

output：
1

分析：
树型DP：首先建树，任选一个结点为根。设要看守住以x为根的子树中所有边，x处有士兵时需要的最少士兵数为yes[x]，x处无士兵时需要的最少士兵数为no[x]。自下而上地计算每个结点的yes值和no值：一个结点的yes值等于它所有子树的yes值与no值的较小值之和再加1；no值等于它所有子树的yes值之和。根结点的yes值和no值中的较小值即为答案。

【参考程序】：

#include<iostream>
using namespace std;
int now[1600],pre[3200],child[3200];
int f0[1600],f1[1600];
int v[1600];
int n;
int MIN(int a,int b)
{
    if (a<b) return a;
    else return b;
}
void dfs(int k)
{
    v[k]=false;f0[k]=0;f1[k]=1;
    while (now[k]>0)
    {
        if (v[child[now[k]]])
        {
            dfs(child[now[k]]);
            f0[k]+=f1[child[now[k]]];
            f1[k]+=MIN(f0[child[now[k]]],f1[child[now[k]]]);
        }
        now[k]=pre[now[k]];
    }
}
int main()
{
    scanf("%d",&n);
    memset(now,-1,sizeof(now));
    int c=0,a,k,b;
    for (int i=1;i<=n;i++)
    {
        scanf("%d%d",&a,&k);
        for (int i=1;i<=k;i++)
        {
            scanf("%d",&b);
            c++;
            child[c]=a;pre[c]=now[b];now[b]=c;
            c++;
            child[c]=b;pre[c]=now[a];now[a]=c;
        }
    }
    memset(f0,0,sizeof(f0));
    memset(f1,0,sizeof(f1));
    memset(v,true,sizeof(v));
    dfs(0);
    int ans=MIN(f0[0],f1[0]);
    printf("%d\n",ans);
    return 0;
}

开拓者 2009-05-31 20:47 发表评论

【pku 回文词 Palindrome】

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

A palindrome is a symmetrical string, that is, a string read identically from left to right as well as from right to left. You are to write a program which, given a string, determines the minimal number of characters to be inserted into the string in order to obtain a palindrome.

As an example, by inserting 2 characters, the string "Ab3bd" can be transformed into a palindrome ("dAb3bAd" or "Adb3bdA"). However, inserting fewer than 2 characters does not produce a palindrome

input：
Your program is to read from standard input. The first line contains one integer: the length of the input string N, 3 <= N <= 5000. The second line contains one string with length N. The string is formed from uppercase letters from 'A' to 'Z', lowercase letters from 'a' to 'z' and digits from '0' to '9'. Uppercase and lowercase letters are to be considered distinct

output：
Your program is to write to standard output. The first line contains one integer, which is the desired minimal number

input：
5
Ab3bd

output：
2

题目翻译：
回文词是一种对称的字符串——也就是说，一个回文词，从左到右读和从右到左读得到的结果是一样的。任意给定一个字符串，通过插入若干字符，都可以变成一个回文词。你的任务是写一个程序，求出将给定字符串变成回文词所需插入的最少字符数。比如字符串“Ab3bd”，在插入两个字符后可以变成一个回文词(“dAb3bAd” “Adb3bdA”)。

分析：就是把输入的字符串倒序和原串求最长公共子序列，原理见我的上一篇解析，原理差不多。

【参考程序】：

#include<iostream>
#include<cstring>
using namespace std;
string s1,s2;
short f[5001][5001];
int n;
int main()
{
    scanf("%d",&n);getchar();
    getline(cin,s1);s1=' '+s1;
    s2=' ';
    for (int i=n;i>=1;i--) s2+=s1[i];
    memset(f,0,sizeof(f));
    for (int i=1;i<=n;i++)
        for (int j=1;j<=n;j++)
            if (s1[i]==s2[j]) f[i][j]=f[i-1][j-1]+1;
            else
            {
                if (f[i-1][j]>f[i][j-1])
                    f[i][j]=f[i-1][j];
                else f[i][j]=f[i][j-1];
            }
    printf("%d\n",n-f[n][n]);
    return 0;
}

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

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

【NOI1995 石子合并】

开拓者 — Fri, 01 May 2009 02:00:00 GMT

在一个园形操场的四周摆放N堆石子,现要将石子有次序地合并成一堆.规定每次只能选相邻的2堆合并成新的一堆，并将新的一堆的石子数，记为该次合并的得分。
试设计出1个算法,计算出将N堆石子合并成1堆的最小得分和最大得分.

input:
数据的第1行试正整数N,1≤N≤100,表示有N堆石子.第2行有N个数,分别表示每堆石子的个数.

output:
输出共2行,第1行为最小得分,第2行为最大得分.

input:
4
4 4 5 9

output:
43
54

【参考程序】：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int s1[201][201],f1[201][201];
int s2[201][201],f2[201][201];
int main()
{
    int n;
    scanf("%d",&n);
    int p;
    memset(s1,127,sizeof(s1));memset(f1,127,sizeof(f1));
    memset(s2,128,sizeof(s2));memset(f2,128,sizeof(f2));
    for (int i=1;i<=n;i++)
    {
        scanf("%d",&p);
        s1[i][i]=s2[i][i]=s1[i+n][i+n]=s2[i+n][i+n]=0;
        f1[i][i]=f2[i][i]=f1[i+n][i+n]=f2[i+n][i+n]=p;
    }
    for (int len=2;len<=2*n;len++)
      for (int i=1;i<=2*n-len+1;i++)
      {
        int j=i+len-1;
        for (int k=i;k<=j-1;k++)
        {
            if (f1[i][j]>f1[i][k]+f1[k+1][j])
            {
                f1[i][j]=f1[i][k]+f1[k+1][j];
                s1[i][j]=s1[i][k]+s1[k+1][j]+f1[i][j];
            }
            else if (f1[i][j]==f1[i][k]+f1[k+1][j])
               if (s1[i][j]>s1[i][k]+s1[k+1][j]+f1[i][j])
                  s1[i][j]=s1[i][k]+s1[k+1][j]+f1[i][j];
            if (f2[i][j]<f2[i][k]+f2[k+1][j])
            {
                f2[i][j]=f2[i][k]+f2[k+1][j];
                s2[i][j]=s2[i][k]+s2[k+1][j]+f2[i][j];
            }
            else if (f2[i][j]==f2[i][k]+f2[k+1][j])
               if (s2[i][j]<s2[i][k]+s2[k+1][j]+f2[i][j])
                 s2[i][j]=s2[i][k]+s2[k+1][j]+f2[i][j];
        }
      }
    int mins=0x7FFFFFFF,maxs=-0x7FFFFFFF;
    for (int i=1;i<=n;i++)
    {
        if (s1[i][i+n-1]<mins) mins=s1[i][i+n-1];
        if (s2[i][i+n-1]>maxs) maxs=s2[i][i+n-1];
    }
    printf("%d\n%d\n",mins,maxs);
    return 0;
}

开拓者 2009-05-01 10:00 发表评论

【观光游览（View）】

开拓者 — Wed, 22 Apr 2009 12:19:00 GMT

【问题描述】

一条街道被分成m格（1<=m<=100），还有n个景点（1<=n<=100），分布在街道上。每个景点可以占据连续的若干格，并且有一个美学值v（0

你的任务是将街道的m个格子分给k个人去考察，使得总的分值最大。

【输入文件】

第一行一个整数m，表示街道的长度。

第二行一个整数n，表示风景点个数。

此后n行，每行描述一个风景点，三个整数x、y和v，表示该风景点是从第x个格子到第y个格子，美学值为v。

最后一行一个整数k，表示考察的人数。

【输出文件】

一个整数，表示最大可以得到的分值。

【输入输出样例】

输入：

3
2
1 2 2
2 3 3
2

输出：
3

【参考程序】：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int f[101][101],c[101][101];
int n,m,k;
int main()
{
        freopen("view.in","r",stdin);
        freopen("view.out","w",stdout);
        scanf("%d",&n);scanf("%d",&m);
        memset(c,0,sizeof(c));
        int x,y,v;
        for (int t=1;t<=m;t++)
        {
                scanf("%d%d%d",&x,&y,&v);
                for (int i=1;i<=x;i++)
                        for (int j=y;j<=n;j++)
                                c[i][j]+=v;
        }
        scanf("%d",&k);
        memset(f,128,sizeof(f));
        f[0][0]=0;
        for (int i=1;i<=n;i++)
                for (int j=1;j<=k;j++)
                        for (int l=0;l<=i-1;l++)
                                if (f[i][j]<f[l][j-1]+c[l+1][i])
                                        f[i][j]=f[l][j-1]+c[l+1][i];
        printf("%d\n",f[n][k]);
        return 0;
}

开拓者 2009-04-22 20:19 发表评论

【最小交换合并问题（Stone）】

开拓者 — Tue, 21 Apr 2009 05:35:00 GMT

【问题描述】

在操场上沿一直线排列着 n堆石子。现要将石子有次序地合并成一堆。规定每次只能选相邻的两堆石子合并成新的一堆，并将新的一堆石子数记为该次合并的得分。允许在第一次合并前对调一次相邻两堆石子的次序。

计算在上述条件下将n堆石子合并成一堆的最小得分和初次交换的位置。

【输入文件】

输入数据共有二行，其中，第1行是石子堆数n≤100；

第2行是顺序排列的各堆石子数（≤20），每两个数之间用空格分隔。

【输出文件】

输出合并的最小得分。

【输入输出样例】

输入：

3
2 5 1

输出：

11

分析：
<石子归并>类型题，只是改了一个可以相邻换而已
f[i][j]：从第i堆开始到第j堆石子分成两堆的最小代价
s[i][j]：从第i堆开始到第j堆石子分成k个不同的两份（1<=k总代价。
则我们只需枚举每次几堆一合（2<=几<=n,1堆的已经知道），和枚举这合并的堆中的方案即可。

状态方程：

【参考程序】：

#include<fstream>
using namespace std;
int f[101][101],s[101][101],a[101];
int n;
int main()
{
        ifstream cin("stone.in");
        ofstream cout("stone.out");
        cin>>n;
        for (int i=1;i<=n;i++) cin>>a[i];
        int min=0x7FFFFFFF;
        for (int x=1;x<=n-1;x++)
        {
                int t=a[x];a[x]=a[x+1];a[x+1]=t;
                memset(f,127,sizeof(f));memset(s,127,sizeof(s));
                for (int i=1;i<=n;i++)
                {
                        f[i][i]=a[i];s[i][i]=0;
                }
                for (int len=2;len<=n;len++)
                        for (int i=1;i<=n-len+1;i++)
                        {
                                int j=i+len-1;
                                for (int k=i;k<=j-1;k++)
                                        if (f[i][j]>f[i][k]+f[k+1][j])
                                        {
                                                f[i][j]=f[i][k]+f[k+1][j];
                                                s[i][j]=f[i][j]+s[i][k]+s[k+1][j];
                                        }
                                        else if (f[i][j]==f[i][k]+f[k+1][j])
                                                if (s[i][j]>f[i][j]+s[i][k]+s[k+1][j])
                                                        s[i][j]=f[i][j]+s[i][k]+s[k+1][j];
                        }
                if (s[1][n]<min) min=s[1][n];
                t=a[x];a[x]=a[x+1];a[x+1]=t;
        }
        cout<<min<<endl;
        return 0;
}

开拓者 2009-04-21 13:35 发表评论

【奇怪的电梯（Lift）】

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

【问题描述】

呵呵，有一天我做了一个梦，梦见了一种很奇怪的电梯。大楼的每一层楼都可以停电梯，而且第i层楼（1<=i<=N）上有一个数字Ki（0<=Ki<=N）。电梯只有四个按钮：开，关，上，下。上下的层数等于当前楼层上的那个数字。当然，如果不能满足要求，相应的按钮就会失灵。例如：3 3 1 2 5代表了Ki（K1=3，K2=3，……），从一楼开始。在一楼，按“上”可以到4楼，按“下”是不起作用的，因为没有-2楼。那么，从A楼到B楼至少要按几次按钮呢？

【输入文件】

输入文件共有二行，第一行为三个用空格隔开的正整数，表示N，A，B（1≤N≤200，1≤A，B≤N），第二行为N个用空格隔开的正整数，表示Ki。

【输出文件】

输出文件仅一行，即最少按键次数，若无法到达，则输出-1。

【输入输出样例】

输入：
5 1 5
3 3 1 2 5

输出：
3

【参考程序】：//简单的宽度优先搜索

#include<fstream>
using namespace std;
int step[201],lift[201];
int n,a,b;
int main()
{
        ifstream cin("lift.in");
        ofstream cout("lift.out");
        cin>>n>>a>>b;
        for (int i=1;i<=n;i++)
        {
                cin>>lift[i];
                step[i]=-1;
        }
        step[a]=0;
        int l=1,p=0,j;
        while (l>0 && step[b]==-1)
        {
           l=0;
           for (int i=1;i<=n;i++)
              if (step[i]==p)
              {
                  j=i+lift[i];//两个方向一上一下
                  if (j<=n && step[j]==-1)
                  {
                      step[j]=p+1;
                      l=1;
                   }
                   j=i-lift[i];
                   if (j>0 && step[j]==-1)
                   {
                       step[j]=p+1;
                       l=1;
                   }
             }
             p++;
        }
        cout<<step[b]<<endl;
        return 0;
}

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

【相似基因（Gene）】

开拓者 — Fri, 17 Apr 2009 07:44:00 GMT

【问题描述】

大家都知道，基因可以看作一个碱基对序列。它包含了4种核苷酸，简记作A，C，G，T。生物学家正致力于寻找人类基因的功能，以利用于诊断疾病和发明药物。

在一个人类基因工作组的任务中，生物学家研究的是：两个基因的相似程度。因为这个研究对疾病的治疗有着非同寻常的作用。两个基因的相似度的计算方法如下：

对于两个已知基因，例如AGTGATG和GTTAG，将它们的碱基互相对应。当然，中间可以加入一些空碱基-，例如：

A	G	T	G	A	T	-	G
-	G	T	-	-	T	A	G

这样，两个基因之间的相似度就可以用碱基之间相似度的总和来描述，碱基之间的相似度如下表所示：

	A	C	G	T	-
A	5	-1	-2	-1	-3
C	-1	5	-3	-2	-4
G	-2	-3	5	-2	-2
T	-1	-2	-2	5	-1
-	-3	-4	-2	-1	*

那么相似度就是：(-3)+5+5+(-2)+(-3)+5+(-3)+5=9。因为两个基因的对应方法不唯一，例如又有：

A	G	T	G	A	T	G
-	G	T	T	A	-	G

相似度为：(-3)+5+5+(-2)+5+(-1)+5=14。规定两个基因的相似度为所有对应方法中，相似度最大的那个。

【输入文件】

共两行。每行首先是一个整数，表示基因的长度；隔一个空格后是一个基因序列，序列中只含A，C，G，T四个字母。1<=序列的长度<=100。

【输出文件】

仅一行，即输入基因的相似度。

【输入输出样例】

输入：

7 AGTGATG
5 GTTAG

输出：
14

【参考程序】：

#include
#include
#include
int p[5][5]={
{5,-1,-2,-1,-3},
{-1,5,-3,-2,-4},
{-2,-3,5,-2,-2},
{-1,-2,-2,5,-1},
{-3,-4,-2,-1,0},
};
int a[101],b[101],opt[101][101];
int len1,len2;
char s1[102],s2[102];
int find_max(int x,int y,int z)
{
        int k=x;
        if (k        if (k        return k;
}
void work()
{
        memset(opt,128,sizeof(opt));
        opt[0][0]=0;
        for (int i=1;i<=len1;i++)
                opt[i][0]=opt[i-1][0]+p[a[i]][4];
        for (int i=1;i<=len2;i++)
                opt[0][i]=opt[0][i-1]+p[4][b[i]];
        for (int i=1;i<=len1;i++)
                for (int j=1;j<=len2;j++)
                {
                        int x=opt[i-1][j-1]+p[a[i]][b[j]],
                            y=opt[i-1][j]+p[a[i]][4],
                            z=opt[i][j-1]+p[4][b[j]];
                        opt[i][j]=find_max(x,y,z);
                }
        printf("%d\n",opt[len1][len2]);
}
int main()
{
        freopen("gene.in","r",stdin);
        freopen("gene.out","w",stdout);
        char cc;
        scanf("%d ",&len1);
        for (int i=1;i<=len1;i++)
        {
                scanf("%c",&cc);
                if (cc=='A') a[i]=0;
                else if (cc=='C') a[i]=1;
                else if (cc=='G') a[i]=2;
                else if (cc=='T') a[i]=3;
        }
        getchar();
        scanf("%d ",&len2);
        for (int i=1;i<=len2;i++)
        {
                scanf("%c",&cc);
                if (cc=='A') b[i]=0;
                else if (cc=='C') b[i]=1;
                else if (cc=='G') b[i]=2;
                else if (cc=='T') b[i]=3;
        }
        work();
        return 0;
}

开拓者 2009-04-17 15:44 发表评论

【饥饿的奶牛（Hunger）】

开拓者 — Thu, 16 Apr 2009 12:53:00 GMT

【问题描述】

John养了若干奶牛，每天晚上奶牛都要进食。由于条件比较简陋，并不一定所有奶牛都能吃到食物。奶牛的进食方式是这样的：John有n个食桶（1<=n<=2000），分别编号为1..n。这些食桶被按照编号排成一行。John将奶牛们分成若干组，每组奶牛总是呆在一起进食的，每组奶牛会提出要求——他们需要吃第start到第end桶中的食物。可能存在若干组奶牛都要吃同一个桶中的食物，从而就产生了冲突，这时John只能满足其中一组的要求，另一些组就只能饿肚子了。

John当然不想让奶牛都饿肚子，所以他希望根据奶牛们提出的请求，满足其中一些组的要求，使得最多的食桶被奶牛食用。这个难题困扰着John，他希望得到你的帮助。

【输入文件】

从文本文件hunger.in中读入数据。

第一行一个整数n，表示奶牛的组数。（1<=n<=1000）

第2～n+1行，每行两个整数start和end，描述了一组奶牛提出的请求。

【输出文件】

一个整数，表示最多有多少个食桶可以被食用。

【输入输出样例】

输入：

1 3

7 8

3 4

输出：

（满足第1组和第2组奶牛的要求，这样1~3号和7~8号这5个食桶可以被食用）

【参考程序】：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct node
{
  int x,y;
} a[1001];
int f[2001];
int n;
int main()
{
   freopen("hunger.in","r",stdin);
   freopen("hunger.out","w",stdout);
   scanf("%d",&n);
   int max=-1;
   for (int i=1;i<=n;i++)
   {
      scanf("%d%d",&a[i].x,&a[i].y);
      if (a[i].y>max) max=a[i].y;
    }
    memset(f,0,sizeof(f));
    for (int i=1;i<=max;i++)
    {
       f[i]=f[i-1];
       for (int j=1;j<=n;j++)
         if (a[j].y==i)
          if (f[a[j].x-1]+a[j].y-a[j].x+1>f[i])
           f[i]=f[a[j].x-1]+a[j].y-a[j].x+1;
    }
    printf("%d\n",f[max]);
    return 0;
}

开拓者 2009-04-16 20:53 发表评论

【胖男孩（Fatboy）】

开拓者 — Thu, 16 Apr 2009 11:28:00 GMT

【问题描述】

麦克正如我们所知的已快乐地结婚，在上个月他胖了70磅。因为手指上的脂肪过多，使他连给他最亲密的朋友斯拉夫克写一个电子邮件都很困难。

每晚麦克都详细地描述那一天他所吃的所有东西，但有时当他只想按一次某键时往往会按了不止一次，并且他的胖手指还会碰到他不想要按的键，麦克也知道自己的手指有问题，因此他在打字的时候很小心，以确保每打一个想要的字符时误打的字符不超过3个，误打的字符可能在正确字符之前也可能在其之后。

当斯拉夫克多次收到读不懂的电子邮件后，他总是要求麦克将电子邮件发3遍，使他容易读懂一点。

编写程序，帮助斯拉夫克根据他所收到的三封电子邮件求出麦克可能写出的最长的信。

【输入文件】

输入文件包含了三行文本。每一行文本包括麦克信件的一种版本。其中所有的字符都由英文字母表中的小写字母组成并且不超过100个。

【输出文件】

输出文件中第一行即唯一的一行数据应该包含斯拉夫克根据所收到的电子邮件推测出的最长信件。你可以相信问题一定有解，但解不一定是唯一的。

【输入输出样例】

输入：
cecqbhvaiaedpibaluk
cabegviapcihlaaugck
adceevfdadaepcialaukd

输出：
cevaiaauk

分析：
就是求三个字符串的最长公共子串.
【参考程序】：

#include<fstream>
#include<cstring>
using namespace std;
const int dx[8]={0,-1,0,0,-1,-1,0,-1};//每个位置字符的取舍情况（0代表不取，-1代表不取）
const int dy[8]={0,0,-1,0,-1,0,-1,-1};
const int dz[8]={0,0,0,-1,0,-1,-1,-1};
int opt[101][101][101],dir[101][101][101];
string s1,s2,s3,ss;
int len1,len2,len3;
void print(int a,int b,int c)
{
        if (dir[a][b][c]==-1) return ;
        print(a+dx[dir[a][b][c]],b+dy[dir[a][b][c]],c+dz[dir[a][b][c]]);
        if (dir[a][b][c]==7) ss+=s1[a];
}
void work()
{
        memset(opt,0,sizeof(opt));
        memset(dir,-1,sizeof(dir));
        for (int i=1;i<=len1;i++)
           for (int j=1;j<=len2;j++)
               for (int k=1;k<=len3;k++)
                   if (s1[i]==s2[j] && s2[j]==s3[k])
                   {
                        opt[i][j][k]=opt[i-1][j-1][k-1]+1;
                         dir[i][j][k]=7;
                   }
                   else
                   {
                       int max=-100000,d;
                        for (int l=1;l<=6;l++)
                        if (opt[i+dx[l]][j+dy[l]][k+dz[l]]>max)
                        {
                               max=opt[i+dx[l]][j+dy[l]][k+dz[l]];
                               d=l;
                        }
                        opt[i][j][k]=max;
                        dir[i][j][k]=d;
                 }
}
int main()
{
        ifstream cin("fatboy.in");
        ofstream cout("fatboy.out");
        cin>>s1;cin>>s2;cin>>s3;
        len1=s1.length();len2=s2.length();len3=s3.length();
        s1=' '+s1;s2=' '+s2;s3=' '+s3;
        work();
        ss="";
        print(len1,len2,len3);
        cout<<ss<<endl;
        return 0;
}

开拓者 2009-04-16 19:28 发表评论

【潜水员（Gas）】

开拓者 — Thu, 16 Apr 2009 06:35:00 GMT

【问题描述】

潜水员为了潜水要使用特殊的装备。他有一个带2种气体的气缸：一个为氧气，一个为氮气。让潜水员下潜的深度需要各种的数量的氧和氮。潜水员有一定数量的气缸。每个气缸都有重量和气体容量。潜水员为了完成他的工作需要特定数量的氧和氮。他完成工作所需气缸的总重的最低限度的是多少？

例如：潜水员有5个气缸。每行三个数字为：氧，氮的（升）量和气缸的重量：

3 36 120
10 25 129
5 50 250
1 45 130
4 20 119

如果潜水员需要5升的氧和60升的氮则总重最小为249（1，2或者4，5号气缸）。

你的任务就是计算潜水员为了完成他的工作需要的气缸的重量的最低值。

【输入文件】

从文本文件gas.in中读入数据。

第一行有2整数t，a（1<=t<=21，1<=a<=79）。它们表示氧，氮各自需要的量。

第二行为整数n（1<=n<=1000）表示气缸的个数。

此后的n行，每行包括ti，ai，wi（1<=ti<=21，1<=ai<=79，1<=wi<=800）3整数。这些各自是：第i个气缸里的氧和氮的容量及汽缸重量。

【输出文件】

仅一行包含一个整数，为潜水员完成工作所需的气缸的重量总和的最低值。

【输入输出样例】

输入：

5 60
5
3 36 120
10 25 129
5 50 250
1 45 130
4 20 119

输出：

249

【参考程序】：

#include<string.h>
#include<stdlib.h>
#include<stdio.h>
int f[30][100],tw[1001],aw[1001],w[1001];
int n,t,a;
int main()
{
        freopen("gas.in","r",stdin);
        freopen("gas.out","w",stdout);
        scanf("%d%d",&t,&a);scanf("%d",&n);
        for (int i=1;i<=n;i++) scanf("%d%d%d",&tw[i],&aw[i],&w[i]);
        for (int i=0;i<=t;i++)
           for (int j=0;j<=a;j++)
               f[i][j]=0xFFFFFFF;
        f[0][0]=0;
        int x,y;
        for (int k=1;k<=n;k++)
           for (int i=t;i>=0;i--)
              for (int j=a;j>=0;j--)
              {
                   x=i+tw[k];if (x>t) x=t;
                   y=j+aw[k];if (y>a) y=a;
                   if (f[i][j]+w[k]<f[x][y]) f[x][y]=f[i][j]+w[k];
              }
        printf("%d\n",f[t][a]);
        return 0;
}

开拓者 2009-04-16 14:35 发表评论

C++博客-【♂Not The Triumph♂O(∩_∩)O哈哈~But The Struggle♂】-文章分类-动态规划&背包

【Vs Liqeuer】

【vijos 添加括号】

【NOIP 2006 开心的金明】

【NOIP 2006 金明的预算方案】

【NOIP 2008 传纸条】

【三取方格数】

【NOI 98 免费馅饼】

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

【三维最大子矩阵 吃西瓜】

【巴蜀 OJ 创意吃鱼法】

【VIJOS 最小与最大】

【最大子矩阵 扑克の阵】

【HNOI 97 凸多边形划分】

【乘积最大(加强版)】

【NOIP 2005 过河】

【机器分配(HNOI 95)】

【Big Barn 巨大的牛棚】

【TJU 挤牛奶】

【Buy Low Buy Lower 逢低吸纳】

【巴蜀OJ 战略游戏】

【pku 回文词 Palindrome】

【rq 大地的秘密】

【NOI1995 石子合并】

【观光游览（View）】

【最小交换合并问题（Stone）】

【参考程序】：

【奇怪的电梯（Lift）】

【相似基因（Gene）】

【饥饿的奶牛（Hunger）】

【胖男孩（Fatboy）】

【潜水员（Gas）】

【三维最大子矩阵吃西瓜】

【最大子矩阵扑克の阵】