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

【记忆化搜索 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 发表评论

【三取方格数】

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

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

【最大子矩阵扑克の阵】

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

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

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

【Window Area 窗体面积】

开拓者 — Sat, 08 Aug 2009 12:24:00 GMT

你刚刚接手一项窗体界面工程。窗体界面还算简单，而且幸运的是，你不必显示实际的窗体。有 5 种基本操作：

创建一个新窗体
将窗体置顶
将窗体置底
删除一个窗体
输出窗体可见部分的百分比（就是，不被其它窗体覆盖的部分）。

在输入文件中，操作以如下的格式出现。

创建一个新窗体：w(I,x,y,X,Y)
将窗体置顶： t(I)
将窗体置底： b(I)
删除一个窗体：d(I)
输出窗体可见部分的百分比：s(I)

I 是每个窗体唯一的标识符，标识符可以是 'a'..'z', 'A'..'Z' 和 '0'..'9' 中的任何一个。输入文件中没有多余的空格。

（x,y）和（X,Y）是窗体的对角。当你创建一个窗体的时候，它自动被“置顶”。你不能用已经存在的标识符来创建窗体，但是你可以删除一个窗体后再用已删除窗体的标识符来创建窗体。坐标用正整数来表示，并且所有的窗体面积都不为 0（x <> X 且 y <> Y）。x 坐标和 y 坐标在 1 —— 32767 的范围内。

格式
PROGRAM NAME: window
INPUT FORMAT
输入文件包含给你的解释程序的一系列命令，每行一个。当输入文件结束时，停止程序。

OUTPUT FORMAT
只对于 s() 命令进行输出。当然，输入文件可能有许多 s() 命令(不超过500次)，所以输出文件应该是一个百分比的序列，每行一个，百分比是窗体可见部分的百分比。百分比应该四舍五入到三位小数。

SAMPLE INPUT (file window.in)
w(a,10,132,20,12)
w(b,8,76,124,15)
s(a)

SAMPLE OUTPUT (file window.out)
49.167

【参考程序】：

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

int L[256],R[256],U[256],D[256];
int prev[256],next[256];
char S[256];
int head,tail;

int get_n()
{
    return S[2];
}
void Swap(int & x,int & y)
{
    int t=x;x=y;y=t;
}
void addtail(int x)
{
    prev[x]=tail; next[x]=-1;
    if (tail!=-1) next[tail]=x;
    tail=x;
    if (head==-1) head=x;
}
void remove(int x)
{
    if (x!=tail) prev[next[x]]=prev[x];
    if (x!=head) next[prev[x]]=next[x];
    if (x==tail) tail=prev[x];
    if (x==head) head=next[x];
}
void addhead(int x)
{
    prev[x]=-1; next[x]=head;
    if (head!=-1) prev[head]=x;
    head=x;
    if (tail==-1) tail=x;
}
int cut(int l,int r,int u,int d,int k)
{
    while (k!=-1 && (R[k]<=l || L[k]>=r || U[k]>=d || D[k]<=u))
        k=next[k];
    if (k==-1) return (r-l)*(d-u);
    int area=0;
    if (L[k]>l)
    {
        area+=cut(l,L[k],u,d,next[k]);
        l=L[k];
    }
    if (R[k]<r)
    {
        area+=cut(R[k],r,u,d,next[k]);
        r=R[k];
    }
    if (U[k]>u) area+=cut(l,r,u,U[k],next[k]);
    if (D[k]<d) area+=cut(l,r,D[k],d,next[k]);
    return area;
}
void solve_w()
{
    int n=get_n();
    sscanf(S+4,"%d,%d,%d,%d",L+n,U+n,R+n,D+n);
    if (L[n]>R[n]) Swap(L[n],R[n]);
    if (U[n]>D[n]) Swap(U[n],D[n]);
    addtail(n);
}
void solve_t()
{
    int n=get_n();
    remove(n);
    addtail(n);
}
void solve_b()
{
    int n=get_n();
    remove(n);
    addhead(n);
}
void solve_d()
{
    int n=get_n();
    remove(n);
}
void solve_s()
{
    int n=get_n();
    int ans=cut(L[n],R[n],U[n],D[n],next[n]);
    printf("%.3lf\n",100.0*(double)ans/((R[n]-L[n])*(D[n]-U[n])));
}
void solve()
{
    switch (S[0])
    {
        case 'w':
            solve_w();
            break;
        case 't':
            solve_t();
            break;
        case 'b':
            solve_b();
            break;
        case 'd':
            solve_d();
            break;
        case 's':
            solve_s();
            break;
    }
}
int main()
{
    freopen("window.in","r",stdin);
    freopen("window.out","w",stdout);
    memset(prev,-1,sizeof(prev));
    memset(next,-1,sizeof(next));
    head=-1; tail=-1;
    while (scanf("%s",S)!=EOF) solve();
    return 0;
}

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

【Milk Measuring 量取牛奶】

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

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

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

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

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

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

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

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

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

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

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

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

SAMPLE OUTPUT (file milk4.out)
2 3 5

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

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

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

【参考程序】：

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

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

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

【Pascal 山脉】

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

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

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

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

样例输入
5
1
2
3
4
5

样例输出
0
1
2
3
4

分析：离散化+树状数组

【参考程序】：

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

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

【Shuttle Puzzle 棋盘游戏】

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

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

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

【The Primes 素数方阵】

开拓者 — Wed, 29 Jul 2009 03:02:00 GMT

摘要: 在下面的方格中，每行，每列，以及两条对角线上的数字可以看作是五位的素数。方格中的行按照从左到右的顺序组成一个素数，而列按照从上到下的顺序。两条对角线也是按照从左到右的顺序来组成。 +---+---+---+---+---+| 1 | 1 | 3 | 5 | 1 |+---+---+---+---+---+| 3 | 3 | 2 | 0 | 3 |+---+---+---+---+---+| 3 ... 阅读全文

开拓者 2009-07-29 11:02 发表评论

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

【The Perfect Stall 完美的牛栏】

开拓者 — Tue, 28 Jul 2009 02:49:00 GMT

农夫约翰上个星期刚刚建好了他的新牛棚，他使用了最新的挤奶技术。不幸的是，由于工程问题，每个牛栏都不一样。第一个星期，农夫约翰随便地让奶牛们进入牛栏，但是问题很快地显露出来：每头奶牛都只愿意在她们喜欢的那些牛栏中产奶。上个星期，农夫约翰刚刚收集到了奶牛们的爱好的信息（每头奶牛喜欢在哪些牛栏产奶）。一个牛栏只能容纳一头奶牛，当然，一头奶牛只能在一个牛栏中产奶。

给出奶牛们的爱好的信息，计算最大分配方案。

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

第一行两个整数，N (0 <= N <= 200) 和 M (0 <= M <= 200) 。N 是农夫约翰的奶牛数量，M 是新牛棚的牛栏数量。

第二行到第N+1行一共 N 行，每行对应一只奶牛。第一个数字 (Si) 是这头奶牛愿意在其中产奶的牛栏的数目 (0 <= Si <= M) 。后面的 Si 个数表示这些牛栏的编号。牛栏的编号限定在区间 (1..M) 中，在同一行，一个牛栏不会被列出两次。

OUTPUT FORMAT:(file stall4.out)

只有一行。输出一个整数，表示最多能分配到的牛栏的数量。

SAMPLE INPUT
5 5
2 2 5
3 2 3 4
2 1 5
3 1 2 5
1 2

SAMPLE OUTPUT
4

参考资料：匈牙利算法(by Beyond the Void)

【参考程序】：

/*
ID: XIONGNA1
PROG: stall4
LANG: C++
*/
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int c[201][201],link[201];
bool vis[201];
int n,m,ans;
bool Find(int now)
{
    for (int i=1;i<=c[now][0];i++)
        if (!vis[c[now][i]])
        {
            vis[c[now][i]]=true;
            if (link[c[now][i]]==0 || Find(link[c[now][i]]))
            {
                link[c[now][i]]=now;
                return true;
            }
        }
    return false;
}
int main()
{
    freopen("stall4.in","r",stdin);
    freopen("stall4.out","w",stdout);
    scanf("%d%d",&n,&m);
    memset(c,0,sizeof(c));
    for (int i=1;i<=n;i++)
    {
        scanf("%d",&c[i][0]);
        for (int j=1;j<=c[i][0];j++)
            scanf("%d",&c[i][j]);
    }
    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-07-28 10:49 发表评论

【Checker Challenge 跳棋的挑战】

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

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

1　 2　 3　 4　 5　 6

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

1 |　 | O |　 |　 |　 |　 |

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

2 |　 |　 |　 | O |　 |　 |

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

3 |　 |　 |　 |　 |　 | O |

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

4 | O |　 |　 |　 |　 |　 |

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

5 |　 |　 | O |　 |　 |　 |

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

6 |　 |　 |　 |　 | O |　 |

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

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

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

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

PROGRAM NAME: checker

INPUT FORMAT:

(checker.in)

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

OUTPUT FORMAT:

(checker.out)

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

input：
6

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

【参考程序】：

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

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

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

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

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

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

【线段树之数列操作】

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

【问题描述】

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

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

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

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

【输入格式】

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

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

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

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

【输出格式】

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

【输入输出样例】

输入:

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

输出:

7
56

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

【参考程序】：

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

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

【观光游览（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 发表评论

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

【参考程序】：

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

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

【相似基因（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 发表评论

【胖男孩（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 发表评论

【钓鱼（Fish）】

开拓者 — Wed, 15 Apr 2009 11:48:00 GMT

【问题描述】

约翰是个垂钓谜，星期天他决定外出钓鱼h小时（1≤h≤16），约翰家附近共有n个池塘（2≤n≤25），这些池塘分布在一条直线上，约翰将这些池塘按离家的距离编上号，依次为L1，L2，…，Ln，约翰家门外就是第一个池塘，所以他到第一个池塘是不用花时间的，约翰可以任选若干个池塘垂钓，并且在每个池塘他都可以呆上任意长的时间，但呆的时间必须为5分钟的倍数，（5分钟为一个单位时间），已知从池塘Li到池塘Li+1要化去约翰ti个单位时间，每个池塘的上鱼率预先也是已知的，池塘Li在第一个单位时间内能钓到的鱼为Fi（0≤Fi≤100），并且每过一个单位时间在单位时间内能钓到的鱼将减少一个常数di（0≤di≤100），现在请你编一个程序计算约翰最多能钓到多少鱼。

【输入文件】

输入文件第一行为一个整数n，第二行为一个整数h，第三行为n个用空格隔开的整数，表示Fi（i=1，2，…，n），第四行为n个用空格隔开的整数，表示di（i=1，2，…，n），第五行为n-1个用空格隔开的整数，表示ti（i=1，2，…，n-1）

【输出文件】

输出一个整数，表示约翰最多能钓到的鱼的数量。

【输入输出样例】

输入：

2
1
10 1
2 5
2

输出：
31

【参考程序】:

#include<string.h>
#include<stdio.h>
#include<stdlib.h>
int f[300][300],fi[300],di[300],ti[300];
int n,h;
int main()
{
    freopen("fish.in","r",stdin);
    freopen("fish.out","w",stdout);
    scanf("%d",&n);scanf("%d",&h);
    h*=12;
    for (int i=1;i<=n;i++) scanf("%d",&fi[i]);
    for (int i=1;i<=n;i++) scanf("%d",&di[i]);
    ti[1]=0;
    for (int i=2;i<=n;i++)
    {
         scanf("%d",&ti[i]);
         ti[i]+=ti[i-1];
    }
    int ans=-1,ts,a1,an;
    memset(f,0,sizeof(f));
    for (int i=1;i<=n;i++)
    {
        ts=h-ti[i];//第i个钓鱼池所钓的最大时间
        if (ts<0) break;
        for (int t=1;t<=ts;t++)
        {
            f[i][t]=f[i][t-1];//继承前一个钓鱼池
            for (int j=0;j<=t;j++)
            {
                 a1=fi[i];an=fi[i]-(j-1)*di[i];
                if (f[i][t]<f[i-1][t-j]+((a1+an)*j)/2)//第i个时间所能钓的最多鱼
                     f[i][t]=f[i-1][t-j]+((a1+an)*j)/2;
             }
       }
       if (ans<f[i][ts]) ans=f[i][ts];
   }
   printf("%d\n",ans);
   return 0;
}

开拓者 2009-04-15 19:48 发表评论

【护卫队（Convoy）】

开拓者 — Tue, 14 Apr 2009 11:20:00 GMT

【问题描述】

护卫车队在一条单行的街道前排成一队，前面河上是一座单行的桥。因为街道是一条单行道，所以任何车辆都不能超车。桥能承受一个给定的最大承载量。为了控制桥上的交通，桥两边各站一个指挥员。护卫车队被分成几个组，每组中的车辆都能同时通过该桥。当一组车队到达了桥的另一端，该端的指挥员就用电话通知另一端的指挥员，这样下一组车队才能开始通过该桥。每辆车的重量是已知的。任何一组车队的重量之和不能超过桥的最大承重量。被分在同一组的每一辆车都以其最快的速度通过该桥。一组车队通过该桥的时间是用该车队中速度最慢的车通过该桥所需的时间来表示的。问题要求计算出全部护卫车队通过该桥所需的最短时间值。

【输入文件】

输入文件第一行包含三个正整数（用空格隔开），第一个整数表示该桥所能承受的最大载重量（用吨表示）；第二个整数表示该桥的长度（用千米表示）；第三个整数表示该护卫队中车辆的总数（n<1000）。接下来的几行中，每行包含两个正整数W和S（用空格隔开），W表示该车的重量（用吨表示），S表示该车过桥能达到的最快速度（用千米/小时表示）。车子的重量和速度是按车子排队等候时的顺序给出的。

【输出文件】

输出文件应该是一个实数，四舍五入精确到小数点后1位，表示整个护卫车队通过该桥所需的最短时间（用分钟表示）。

【输入输出样例】

输入：

100 5 10
40 25
50 20
50 20
70 10
12 50
9 70
49 30
38 25
27 50
19 70

输入：

75.0

【参考程序】：

#include<string.h>
#include<stdlib.h>
#include<stdio.h>
double f[1001];
int w[1001],s[1001];
int mw,ml,n;
int main()
{
        freopen("convoy.in","r",stdin);
        freopen("convoy.out","w",stdout);
        scanf("%d%d%d",&mw,&ml,&n);
        for (int i=1;i<=n;i++)
        {
                scanf("%d%d",&w[i],&s[i]);
                f[i]=0xFFFFFFF;
        }
        f[0]=0.0;
        long long temp,lest;
        for (int i=1;i<=n;i++)
        {
                temp=w[i];lest=s[i];
                f[i]=f[i-1]+(ml*1.0)/lest;
                for (int j=i-1;j>=0;j--)
                {
                        if (temp>mw) break;
                        if (f[i]>f[j]+(ml*1.0)/lest)
                                f[i]=f[j]+(ml*1.0)/lest;
                        temp+=w[j];
                        if (lest>s[j]) lest=s[j];
                }
        }
        printf("%0.1lf\n",f[n]*60.0);
        return 0;
}

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

【筷子（Chop）】

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

【问题描述】

A先生有很多双筷子。确切的说应该是很多根，因为筷子的长度不一，很难判断出哪两根是一双的。这天，A先生家里来了K个客人，A先生留下他们吃晚饭。加上A先生，A夫人和他们的孩子小A，共K+3个人。每人需要用一双筷子。A先生只好清理了一下筷子，共N根，长度为T1，T2，T3，……，TN。现在他想用这些筷子组合成K+3双，使每双的筷子长度差的平方和最小。（怎么不是和最小？？这要去问A先生了，呵呵）

【输入文件】

输入文件共有两行，第一行为两个用空格隔开的整数，表示N，K（1≤N≤100，0

【输出文件】

输出文件仅一行。如果凑不齐K+3双，输出-1，否则输出长度差平方和的最小值。

【输入输出样例】

输入：

10 1

1 1 2 3 3 3 4 6 10 20

输入：

说明：

第一双 1 1

第二双 2 3

第三双 3 3

第四双 4 6

(1-1)^2+(2-3)^2+(3-3)^2+(4-6)^2=5

分析：状态定义：F[i][j]：j个人准备i双筷子的最小平方差和。
F[i][j]=max(f[i-1][j],f[i-2][j-1]+a[i]-(a[i-1])^2)

【参考程序】：

#include<string.h>
#include<stdlib.h>
#include<stdio.h>
long a[101],f[101][54];
long n,k;
void ssort()
{
     long tt;
     for (int i=1;i<=n-1;i++)
        for (int j=n;j>=i+1;j--)
          if (a[j]<a[j-1])
          {
               tt=a[j];a[j]=a[j-1];a[j-1]=tt;
          }
}
int main()
{
        scanf("%ld%ld",&n,&k);
        if (n<(k+3)*2)
        {
              printf("-1\n");
              exit(0);
        }
        for (int i=1;i<=n;i++) scanf("%ld",&a[i]);
        ssort();
        for (int i=0;i<=n;i++)
            for (int j=0;j<=k+3;j++)
                f[i][j]=0xfffffff;
        f[0][0]=0;
        //f[i][j]:i支筷子组成j个人的最小平方差和
        for (int i=1;i<=n;i++)
            for (int j=1;j<=k+3;j++)
                if (i>=j*2)
                { //假设i支筷子不用那么就由i-1去制造j个人需要的筷子数
                    long x=f[i-1][j],
                            y=f[i-2][j-1]+(a[i]-a[i-1])*(a[i]-a[i-1]);
                    //当前要多一个人那么就需要i跟i-1组合成一对个第j个人+平方差和
                    if (x<f[i][j]) f[i][j]=x;
                    if (y<f[i][j]) f[i][j]=y;
                }
        printf("%ld\n",f[n][k+3]);
        system("pause");
        return 0;
}

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

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

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

【三取方格数】

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

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

【最大子矩阵 扑克の阵】

【HNOI 97 凸多边形划分】

【乘积最大(加强版)】

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

【Window Area 窗体面积】

【Milk Measuring 量取牛奶】

【TJU 挤牛奶】

【Pascal 山脉】

【Shuttle Puzzle 棋盘游戏】

【The Primes 素数方阵】

【Buy Low Buy Lower 逢低吸纳】

【The Perfect Stall 完美的牛栏】

【Checker Challenge 跳棋的挑战】

【巴蜀OJ 战略游戏】

【rq 大地的秘密】

【NOI1995 石子合并】

【线段树之数列操作】

【观光游览（View）】

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

【参考程序】：

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

【相似基因（Gene）】

【胖男孩（Fatboy）】

【潜水员（Gas）】

【钓鱼（Fish）】

【护卫队（Convoy）】

【筷子（Chop）】

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

【最大子矩阵扑克の阵】

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