C++博客-心如止水-随笔分类-题目分类：动态规划

HDU 2452 Navy maneuvers

lee1r — Wed, 24 Aug 2011 11:58:00 GMT

JJ哥让我帮他去看这道题，我顺手A了，结果发现这题的耗时竟然排第一了。
d[i][1]表示从i点出发可以取得的最大值，d[i][0]则表示最小值，那么就有d[i][1]=max{ d[j][0] } + r[i]，d[i][0]=min{ d[j][1] } + r[i]，其中有一条的边。
以下是我的代码：

/*
* Author:  lee1r
* Created Time:  2011/8/24 19:36:33
* File Name: hdu2452.cpp
*/
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#define L(x) ((x)<<1)
#define R(x) ((x)<<1|1)
#define Half(x) ((x)>>1)
#define Lowbit(x) ((x)&(-(x)))
using namespace std;
const int kInf(0x7f7f7f7f);
const double kEps(1e-8);
typedef unsigned int uint;
typedef long long int64;
typedef unsigned long long uint64;

bool scanf(int &num)
{
    char in;
    while((in=getchar())!=EOF && (in>'9' || in<'0'));
    if(in==EOF) return false;
    num=in-'0';
    while(in=getchar(),in>='0' && in<='9') num*=10,num+=in-'0';
    return true;
}

const int kMaxn(10007);
const int kMaxm(1000007);

int n,m,f,start,r[kMaxn],d[kMaxn][2];
int cnt,first[kMaxn],next[kMaxm],e[kMaxm];
bool into[kMaxn],out[kMaxn];

void Clear()
{
    cnt=-1;
    memset(first,-1,sizeof(first));
}

void AddEdge(int u,int v)
{
    cnt++;
    e[cnt]=v;
    next[cnt]=first[u];
    first[u]=cnt;
}

int dp(int u,int sign)
{
    if(d[u][sign]!=-1)
        return d[u][sign];
    d[u][sign]=r[u];
    int t(sign?0:kInf);
    for(int i=first[u];i!=-1;i=next[i])
    {
        int v(e[i]);
        if(sign)
            t=max(t,dp(v,0));
        else
            t=min(t,dp(v,1));
    }
    d[u][sign]+=t;
    return d[u][sign];
}

int main()
{
    #ifndef ONLINE_JUDGE
    //freopen("data.in","r",stdin);
    #endif

    while(scanf(n) && scanf(m) && scanf(f))
    {
        for(int i=1;i<=n;i++)
            scanf(r[i]);

        Clear();
        memset(into,false,sizeof(into));
        memset(out,false,sizeof(out));
        while(m--)
        {
            int u,v;
            scanf(u);
            scanf(v);
            AddEdge(u,v);
            into[v]=true;
            out[u]=true;
        }

        memset(d,-1,sizeof(d));
        for(int i=1;i<=n;i++)
        {
            if(!out[i])
                d[i][0]=d[i][1]=r[i];
            else if(!into[i])
                start=i;
        }

        if(dp(start,1)>=f)
            printf("Victory\n");
        else
            printf("Glory\n");
    }

    return 0;
}

lee1r 2011-08-24 19:58 发表评论

POJ 1276 Cash Machine

lee1r — Tue, 09 Aug 2011 02:38:00 GMT

多重背包问题。将ni拆分成1，2，4，...，2^(k-1)，ni-2^k+1，易证这种拆分可以组合出1..ni之间的所有数字。于是转化成01背包求解。
以下是我的代码：

/*
* Author:  lee1r
* Created Time:  2011/8/9 10:20:19
* File Name: poj1276.cpp
*/
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#define L(x) ((x)<<1)
#define R(x) (((x)<<1)+1)
#define Half(x) ((x)>>1)
#define lowbit(x) ((x)&(-(x)))
using namespace std;
const int kInf(0x7f7f7f7f);
const double kEps(1e-8);
typedef long long int64;
typedef unsigned long long uint64;

const int kMaxn(10007);
const int kMaxm(100007);

int n,m,cnt,w[kMaxn],c[kMaxn],d[kMaxm];

int main()
{
    //freopen("data.in","r",stdin);

    while(scanf("%d",&m)==1)
    {
        cnt=0;
        scanf("%d",&n);
        for(int i=1;i<=n;i++)
        {
            int ni,wi;
            scanf("%d%d",&ni,&wi);
            for(int i=1;i<=ni;ni-=i,i<<=1)
            {
                cnt++;
                w[cnt]=wi*i;
                c[cnt]=wi*i;
            }
            if(ni>0)
            {
                cnt++;
                w[cnt]=wi*ni;
                c[cnt]=wi*ni;
            }
        }

        int ans(0);
        memset(d,0,sizeof(d));
        for(int i=1;i<=cnt;i++)
            for(int j=m;j>=c[i];j--)
                d[j]=max(d[j],d[j-c[i]]+w[i]);
        for(int i=0;i<=m;i++)
            ans=max(ans,d[i]);

        printf("%d\n",ans);
    }

    return 0;
}

lee1r 2011-08-09 10:38 发表评论

UVa 10404 Bachet's Game

lee1r — Thu, 04 Aug 2011 01:33:00 GMT

简单博弈。
以下是我的代码：

/*
* Author:  lee1r
* Created Time:  2011/8/4 8:56:39
* File Name: uva10407.cpp
*/
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#define L(x) ((x)<<1)
#define R(x) (((x)<<1)+1)
#define Half(x) ((x)>>1)
#define lowbit(x) ((x)&(-(x)))
using namespace std;
const int kInf(0x7f7f7f7f);
const double kEps(1e-11);
typedef long long int64;
typedef unsigned long long uint64;

const int kMaxn(1000007);

int n,m,r[kMaxn];
bool d[kMaxn];

int main()
{
    //freopen("data.in","r",stdin);

    while(scanf("%d%d",&n,&m)==2)
    {
        for(int i=1;i<=m;i++)
            scanf("%d",&r[i]);
        d[0]=false;
        for(int i=1;i<=n;i++)
        {
            d[i]=false;
            for(int j=1;j<=m;j++)
                if(i-r[j]>=0)
                    if(d[i-r[j]]==false)
                    {
                        d[i]=true;
                        break;
                    }
        }
        if(d[n])
            printf("Stan wins\n");
        else
            printf("Ollie wins\n");
    }

    return 0;
}

lee1r 2011-08-04 09:33 发表评论

UVa 10891 Game of Sum

lee1r — Thu, 04 Aug 2011 00:19:00 GMT

题解请参考：http://hi.baidu.com/knowledgetime/blog/item/49355560beadbf6e0c33fabc.html
以下是我的代码：

/*
* Author:  lee1r
* Created Time:  2011/8/4 7:54:43
* File Name: uva10891.cpp
*/
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#define L(x) ((x)<<1)
#define R(x) (((x)<<1)+1)
#define Half(x) ((x)>>1)
#define lowbit(x) ((x)&(-(x)))
using namespace std;
const int kInf(0x7f7f7f7f);
const double kEps(1e-11);
typedef long long int64;
typedef unsigned long long uint64;

const int kMaxn(107);

int n,r[kMaxn],sum[kMaxn],d[kMaxn][kMaxn];

int Sum(int i,int j)
{
    return sum[j]-sum[i-1];
}

int dp(int i,int j)
{
    if(d[i][j]!=-1)
        return d[i][j];
    d[i][j]=Sum(i,j);
    for(int k=i;k<j;k++)
        d[i][j]=max(d[i][j],Sum(i,j)-dp(k+1,j));
    for(int k=i+1;k<=j;k++)
        d[i][j]=max(d[i][j],Sum(i,j)-dp(i,k-1));
    return d[i][j];
}

int main()
{
    //freopen("data.in","r",stdin);

    while(scanf("%d",&n)==1 && n)
    {
        sum[0]=0;
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&r[i]);
            sum[i]=sum[i-1]+r[i];
        }

        memset(d,-1,sizeof(d));
        for(int i=1;i<=n;i++)
            d[i][i]=r[i];
        printf("%d\n",dp(1,n)-Sum(1,n)+dp(1,n));
    }

    return 0;
}

lee1r 2011-08-04 08:19 发表评论

UVa 10651 Pebble Solitaire

lee1r — Wed, 03 Aug 2011 11:27:00 GMT

DP题，状态总量为2^12，其实可以用对称性减少一半状态数。
以下是我的代码：

/*
* Author:  lee1r
* Created Time:  2011/8/3 12:18:41
* File Name: uva10651.cpp
*/
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#define L(x) ((x)<<1)
#define R(x) (((x)<<1)+1)
#define Half(x) ((x)>>1)
#define lowbit(x) ((x)&(-(x)))
using namespace std;
const int kInf(0x7f7f7f7f);
const double kEps(1e-11);
typedef long long int64;
typedef unsigned long long uint64;

int d[4107];

int dp(int x)
{
    if(d[x]!=-1)
        return d[x];
    d[x]=0;
    for(int i=0;i<12;i++)
        if(x&(1<<i))
            d[x]++;
    for(int i=0;i<10;i++)
        if((x&(1<<i)) && (x&(1<<(i+1))) && !(x&(1<<(i+2))))
        {
            int newx(x);
            newx=(~((~newx)|(1<<i)));
            newx=(~((~newx)|(1<<(i+1))));
            newx=(newx|(1<<(i+2)));
            d[x]=min(d[x],dp(newx));
        }
    for(int i=0;i<10;i++)
        if(!(x&(1<<i)) && (x&(1<<(i+1))) && (x&(1<<(i+2))))
        {
            int newx(x);
            newx=(~((~newx)|(1<<(i+1))));
            newx=(~((~newx)|(1<<(i+2))));
            newx=(newx|(1<<i));
            d[x]=min(d[x],dp(newx));
        }
    return d[x];
}

int main()
{
    //freopen("data.in","r",stdin);

    memset(d,-1,sizeof(d));

    int T;
    cin>>T;
    while(T--)
    {
       string s;
       cin>>s;
       int n(0);
       for(int i=0;i<s.size();i++)
           if(s[i]=='o')
               n=(n|(1<<i));
       printf("%d\n",dp(n));
    }

    return 0;
}

lee1r 2011-08-03 19:27 发表评论

UVa 562 Dividing coins

lee1r — Wed, 25 May 2011 12:13:00 GMT

题目大意：给出n个数，分成两组，每组和的差尽量小。
背包问题。计算出n个数所有的组合情况即可。具体做法是，如果d[j]==true，那么d[j+r[i]]也一定为true。
以下是我的代码：

#include<cstdio>
#include<cstring>
using namespace std;
const int kMaxn(107);

int n,sum,r[kMaxn];
bool d[50007];

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    #endif

    int T;
    scanf("%d",&T);
    while(T--)
    {
        sum=0;
        scanf("%d",&n);
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&r[i]);
            sum+=r[i];
        }

        memset(d,false,50007*sizeof(bool));
        d[0]=true;
        for(int i=1;i<=n;i++)
            for(int j=sum-d[i];j>=0;j--)
                if(d[j])
                    d[j+r[i]]=true;

        for(int i=(sum>>1);i>=0;i--)
            if(d[i])
            {
                printf("%d\n",sum-(i<<1));
                break;
            }
    }

    return 0;
}

lee1r 2011-05-25 20:13 发表评论

UVa 357 Let Me Count The Ways

lee1r — Tue, 24 May 2011 13:14:00 GMT

题目大意：求出共有多少种组合方案，使得数字之和为n。可以选择的数字有1，5，10，25，50（用数组c存储）。
用d[i][j]表示：使用的最大数字不超过c[j]、和为i的方案总数。考虑这样分类：该方案的最后一个数为c[j]；该方案的最后一个数不为c[j]。那么就有d[i][j]=d[i-c[j]][j]+d[i][j-1]。边界条件为d[0][i]=1。
以下是我的代码：

#include<iostream>
#include<cstdio>
using namespace std;
const int kMaxn(30000);
const int c[]={1,5,10,25,50};

long long d[kMaxn+7][5];

void Init()
{
    for(int i=0;i<5;i++)
        d[0][i]=1;
    for(int i=1;i<=kMaxn;i++)
        for(int j=0;j<5;j++)
        {
            d[i][j]=0;
            if(i>=c[j])
                d[i][j]+=d[i-c[j]][j];
            if(j>=1)
                d[i][j]+=d[i][j-1];
        }
}

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    #endif

    Init();

    int n;
    while(scanf("%d",&n)==1)
    {
        if(d[n][4]<=1)
            cout<<"There is only 1 way to produce "<<n<<" cents change."<<endl;
        else
            cout<<"There are "<<d[n][4]<<" ways to produce "<<n<<" cents change."<<endl;
    }

    return 0;
}

lee1r 2011-05-24 21:14 发表评论

UVa 10192 Vacation

lee1r — Tue, 24 May 2011 09:05:00 GMT

题目大意：最长公共子序列。
以下是我的代码：

#include<iostream>
#include<string>
#include<algorithm>
#include<cstdio>
using namespace std;
const int kMaxn(107);

int d[kMaxn][kMaxn];

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    #endif

    int T(0);
    string a,b;
    while(getline(cin,a) && a!="#")
    {
        getline(cin,b);
        a.insert(0," ");
        b.insert(0," ");

        d[0][0]=d[1][0]=d[0][1]=0;
        for(int i=1;i<a.size();i++)
            for(int j=1;j<b.size();j++)
                if(a[i]==b[j])
                    d[i][j]=d[i-1][j-1]+1;
                else
                    d[i][j]=max(d[i-1][j],d[i][j-1]);

        T++;
        printf("Case #%d: you can visit at most %d cities.\n",T,d[a.size()-1][b.size()-1]);
    }

    return 0;
}

lee1r 2011-05-24 17:05 发表评论

UVa 10066 The Twin Towers

lee1r — Tue, 24 May 2011 08:14:00 GMT

题目大意：最长公共子序列。
DP。
注意：每组数据之后输出一个空行。
以下是我的代码：

#include<algorithm>
#include<cstdio>
using namespace std;
const int kMaxn(107);

int d[kMaxn][kMaxn];

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    #endif

    int T(0),n,m;
    while(scanf("%d%d",&n,&m)==2 && (n || m))
    {
        int a[kMaxn],b[kMaxn];
        for(int i=1;i<=n;i++)
            scanf("%d",&a[i]);
        for(int i=1;i<=m;i++)
            scanf("%d",&b[i]);

        d[0][0]=d[0][1]=d[1][0]=0;
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++)
                if(a[i]==b[j])
                    d[i][j]=d[i-1][j-1]+1;
                else
                    d[i][j]=max(d[i-1][j],d[i][j-1]);

        T++;
        printf("Twin Towers #%d\n",T);
        printf("Number of Tiles : %d\n\n",d[n][m]);
    }

    return 0;
}

lee1r 2011-05-24 16:14 发表评论

UVa 111 History Grading

lee1r — Tue, 24 May 2011 00:15:00 GMT

开始练习DP的第一题，受挫，无语。
主要在于输入数据的格式弄得我很不习惯，输入的并不是答案或者学生填写结果的顺序。
最长公共子序列问题，也可以最长上升子序列来做。
以下是我的代码：

#include<iostream>
#include<sstream>
#include<string>
#include<algorithm>
#include<cstdio>
using namespace std;
const int kMaxn(27);

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    #endif

    int n;
    scanf("%d",&n);
    int ans[kMaxn];
    for(int i=1;i<=n;i++)
    {
        int t;
        scanf("%d",&t);
        ans[t]=i;
    }
    cin.get();
    string line;
    while(getline(cin,line))
    {
        istringstream sin(line);
        int r[kMaxn];
        for(int i=1;i<=n;i++)
        {
            int t;
            sin>>t;
            r[t]=find(ans+1,ans+n+1,i)-ans;
        }

        int len(0),d[kMaxn]={0};
        for(int i=1;i<=n;i++)
        {
            if(r[i]>d[len])
            {
                len++;
                d[len]=r[i];
            }
            else
            {
                int pos=lower_bound(d+1,d+len+1,r[i])-d;
                d[pos]=r[i];
            }
        }

        printf("%d\n",len);
    }

    return 0;
}

lee1r 2011-05-24 08:15 发表评论

UVa 10827 Maximum sum on a torus

lee1r — Sat, 21 May 2011 04:16:00 GMT

最大子矩阵问题的增强版～难度增加了不少！但是我莫名其妙地一次AC了……AC之后发现某个地方和我原本设计的算法不符……修改到和我设计的算法符合……然后WA了（这难道就是传说中的RP么）。
我说说我AC的算法：首先，把原矩阵复制成4份，这样就解决了矩阵循环的问题了；然后按照基础最大子矩阵的方法枚举上下边，但是需要加入一个限制：上下边的距离不能超过n（这个很好理解）；上下边固定住以后，同样和基础最大子矩阵的做法一样：DP。同时记录当前序列的长度，长度如果等于n，从这个点到它前n个点的DP状态需要重新计算（相当于重新选定了当前行的起点，这样会使算法复杂度增高到O(n^4)，不过长度等于n的情况太少啦，所以依然不会超时）。
后记：本人之前的算法还是可行的，只不过我代码不小心写错啦～具体和上面的不同之处就在于检测到长度等于n之后，计算当前点的状态不再使用递推，而改用枚举序列起点的方式，两种方法复杂度相同。
之前认为我本来的算法有误是这样想的：比如当前计算出一个[i,i+n-1]的序列，现在要计算i+n这一个点的状态。直接枚举[p,i+n]（其中i+1<=p<=i+n）这些序列即可。之前认为最优解可能出现在[i+1,p-1]这一段，所以需要重新从i+1开始递推，后来想想是不可能出现这种情况的。
枚举的方法修改成了如下代码：

if(len==n)
{
    now=-kInf;
    len=0;
    for(int p=k-n+1;p<=k;p++)
    {
        if(now<d[j][k]-d[j][p-1]-d[i-1][k]+d[i-1][p-1])
        {
            now=d[j][k]-d[j][p-1]-d[i-1][k]+d[i-1][p-1];
            len=k-p+1;
        }
    }
    tmp=max(tmp,now);
}

以下是我的代码：

#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;
const int kMaxn(77);
const int kInf(0x7f7f7f7f);

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    #endif

    int T;
    scanf("%d",&T);
    while(T--)
    {
        int n;
        scanf("%d",&n);
        int r[kMaxn<<1][kMaxn<<1];
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                scanf("%d",&r[i][j]);
        for(int i=1;i<=n;i++)
            for(int j=n+1;j<=(n<<1);j++)
                r[i][j]=r[i][j-n];
        for(int i=n+1;i<=(n<<1);i++)
            for(int j=1;j<=n;j++)
                r[i][j]=r[i-n][j];
        for(int i=n+1;i<=(n<<1);i++)
            for(int j=n+1;j<=(n<<1);j++)
                r[i][j]=r[i-n][j-n];

        int d[kMaxn<<1][kMaxn<<1];
        memset(d,0,(kMaxn<<1)*(kMaxn<<1)*sizeof(int));
        for(int i=1;i<=(n<<1);i++)
            for(int j=1;j<=(n<<1);j++)
                d[i][j]=d[i-1][j]+d[i][j-1]-d[i-1][j-1]+r[i][j];

        int ans(-kInf);
        for(int i=1;i<=(n<<1);i++)
            for(int j=i;j<=(n<<1) && j<=i+n-1;j++)
            {
                int t[kMaxn<<1];
                for(int k=1;k<=(n<<1);k++)
                    t[k]=d[j][k]-d[j][k-1]-d[i-1][k]+d[i-1][k-1];

                int tmp(-kInf),now(-kInf),len(0);
                for(int k=1;k<=(n<<1);k++)
                {
                    if(len==n)
                    {
                        now=-kInf;
                        len=0;
                        for(int p=k-n+1;p<=k;p++)
                        {
                            if(now+t[p]>t[p])
                            {
                                now=now+t[p];
                                len++;
                            }
                            else
                            {
                                now=t[p];
                                len=1;
                            }
                            tmp=max(tmp,now);
                        }
                    }
                    else
                    {
                        if(now+t[k]>t[k])
                        {
                            now=now+t[k];
                            len++;
                        }
                        else
                        {
                            now=t[k];
                            len=1;
                        }
                        tmp=max(tmp,now);
                    }
                }
                ans=max(ans,tmp);
            }

        printf("%d\n",ans);
    }

    return 0;
}

lee1r 2011-05-21 12:16 发表评论

HDU 1003 Max Sum

lee1r — Thu, 10 Mar 2011 14:03:00 GMT

采用DP。当前的数字，要么加在之前的若干个数字的后面，要么另外成为一个序列的开头；具体是如何决策，需要比较当前数字t与之前若干数字的和sum的大小。
以下是我的代码：

#include<iostream>
#include<cstdio>
using namespace std;
const int kInf (200000000);

int main()
{
    /*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/

    int T;
    cin>>T;
    for(int k=1;k<=T;k++)
    {
        int n;
        int sum(-kInf),now_left(0),now_right(0);
        int ans_value(-kInf),ans_left(now_left),ans_right(now_right);

        cin>>n;
        for(int i=1;i<=n;i++)
        {
            int t;
            cin>>t;
            if(sum+t<t)
            {
                sum=t;
                now_left=now_right=i;
            }
            else if(sum+t==t)
            {
                sum=t;
                now_right++;
            }
            else if(sum+t>t)
            {
                sum+=t;
                now_right++;
            }

            if(ans_value<sum || (ans_value==sum && ans_left>now_left) || (ans_value==sum && ans_left==now_left && ans_right>now_right))
            {
                ans_value=sum;
                ans_left=now_left;
                ans_right=now_right;
            }
        }

        if(k!=1) cout<<endl;
        cout<<"Case "<<k<<":"<<endl;
        cout<<ans_value<<" "<<ans_left<<" "<<ans_right<<endl;
    }

return 0;
}

lee1r 2011-03-10 22:03 发表评论

NOIP 2010 TG 2 乌龟棋

lee1r — Tue, 08 Mar 2011 04:00:00 GMT

我的NOIP2010就杯具在这道题上了，多么简单啊！考完回来坐在那立刻就想起来了！
唉……杯具的省二等！这道题拿下不就省一了么。
直到保送之后、直到今天，我才能静下心来AC这道题。
以下是我的代码：

#include<iostream>
using namespace std;
const int kMaxn (351),kMaxc (41);
int max(int a,int b){return (a>b?a:b);}

int d[kMaxc][kMaxc][kMaxc][kMaxc];

int main()
{
    /*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/

    int n,m,r[kMaxn],cards_count[5]={0};
    cin>>n>>m;
    for(int i=1;i<=n;i++)
        cin>>r[i];
    for(int i=1;i<=m;i++)
    {
        int t;
        cin>>t;
        cards_count[t]++;
    }

    for(int i=0;i<=cards_count[1];i++)
    for(int j=0;j<=cards_count[2];j++)
    for(int k=0;k<=cards_count[3];k++)
    for(int l=0;l<=cards_count[4];l++)
    {
        d[i][j][k][l]=r[1];
        int now=1+i+2*j+3*k+4*l;
        if(i>=1)
            d[i][j][k][l]=max(d[i][j][k][l],d[i-1][j][k][l]+r[now]);
        if(j>=1)
            d[i][j][k][l]=max(d[i][j][k][l],d[i][j-1][k][l]+r[now]);
        if(k>=1)
            d[i][j][k][l]=max(d[i][j][k][l],d[i][j][k-1][l]+r[now]);
        if(l>=1)
            d[i][j][k][l]=max(d[i][j][k][l],d[i][j][k][l-1]+r[now]);
    }

    cout<<d[cards_count[1]][cards_count[2]][cards_count[3]][cards_count[4]]<<endl;

return 0;
}

lee1r 2011-03-08 12:00 发表评论

HDU 1257 最少拦截系统

lee1r — Mon, 07 Mar 2011 10:13:00 GMT

最少拦截系统的个数等于最长上升子序列的长度。别问我为什么，我不知道。这是个结论，之前看到过。
用O(nlogn)的最长上升子序列算法即可。

#include<iostream>
#include<vector>
#include<algorithm>
#include<cstdio>
using namespace std;

int main()
{
    /*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/

    int n;
    while(cin>>n)
    {
        int x,ans(0);
        vector<int> d(n+1,-1);
        for(int i=1;i<=n;i++)
        {
            cin>>x;
            if(x>d[ans])
                d[++ans]=x;
            else
            {
                vector<int>::iterator p=upper_bound(d.begin(),d.begin()+ans+1,x);
                *p=x;
            }
        }
        cout<<ans<<endl;
    }

return 0;
}

lee1r 2011-03-07 18:13 发表评论

tyvj P1097 MM不哭

lee1r — Sat, 30 Oct 2010 12:15:00 GMT

假设此时已经安慰好了第i个MM和第j个MM及其之间的所有MM。如果此时站在第i个MM所在的位置，用d[i,j,0]表示之后需要消耗的最小RP；如果此时站在第j个MM所在的位置，用d[i,j,1]表示在此之后需要消耗的最小RP。
那么就有：
d[i,j,0]=min{ d[i-1,j,0]+abs(r[i]-r[i-1])*(s[n]-s[j]+s[i-1]),
d[i,j+1,1]+abs(r[i]-r[j+1])*(s[n]-s[j]+s[i-1]) }；
d[i,j,1]时的情况可以类似写出。
其中r[i]表示第i个MM所在的位置，s[i]表示前i个MM的w[i]的和。
以下是我的代码：

#include<iostream>
#include<string.h>
#include<stdlib.h>
#define maxn 1007
#define inf 2000000000
using namespace std;
long min(long a,long b){return (a<b?a:b);}

long n,v,r[maxn],w[maxn],s[maxn];
long d[maxn][maxn][2];

long dp(long i,long j,long k)
{
    if(d[i][j][k]!=-1) return d[i][j][k];
    d[i][j][k]=inf;
    if(k==0)
    {
       if(i-1>=0)
         d[i][j][k]=min(d[i][j][k],dp(i-1,j,0)+abs(r[i]-r[i-1])*(s[n]-s[j]+s[i-1]));
       if(j+1<=n+1)
         d[i][j][k]=min(d[i][j][k],dp(i,j+1,1)+abs(r[i]-r[j+1])*(s[n]-s[j]+s[i-1]));
    }
    else if(k==1)
    {
       if(i-1>=0)
         d[i][j][k]=min(d[i][j][k],dp(i-1,j,0)+abs(r[j]-r[i-1])*(s[n]-s[j]+s[i-1]));
       if(j+1<=n+1)
         d[i][j][k]=min(d[i][j][k],dp(i,j+1,1)+abs(r[j]-r[j+1])*(s[n]-s[j]+s[i-1]));
    }
    return d[i][j][k];
}

int main()
{
    cin>>n>>v;
    s[0]=0;
    for(long i=1;i<=n;i++)
    {
       cin>>r[i]>>w[i];
       s[i]=s[i-1]+w[i];
    }
    //  Input

    memset(d,-1,sizeof(d));
    d[0][n+1][0]=d[0][n+1][1]=0;
    //  Init

    cout<<dp(v,v,0)<<endl;
    //  Output
return 0;
}

lee1r 2010-10-30 20:15 发表评论

tyvj P1076 数字三角形2

lee1r — Fri, 29 Oct 2010 14:50:00 GMT

判断存在性的动态规划，d[i,j,k]==true表示存在着一条到达点（i，j）的路径，路径之和mod 100的结果为k。
以下是我的代码：

#include<iostream>
#include<string.h>
#define maxn 27
#define maxm 100
using namespace std;

long n,ans,r[maxn][maxn];
bool d[maxn][maxn][maxm];

int main()
{
    cin>>n;
    for(long i=1;i<=n;i++)
      for(long j=1;j<=i;j++)
        cin>>r[i][j];
    //  Input

    memset(d,false,sizeof(d));
    d[1][1][r[1][1]%maxm]=true;
    //  Init

    for(long i=2;i<=n;i++)
      for(long j=1;j<=i;j++)
        for(long k=0;k<maxm;k++)
          if(d[i-1][j][k])
            d[i][j][(k+r[i][j])%maxm]=true;
          else if(j>=2&&d[i-1][j-1][k])
            d[i][j][(k+r[i][j])%maxm]=true;
    //  DP

    ans=0;
    for(long i=1;i<=n;i++)
      for(long j=maxm-1;j>=0;j--)
        if(d[n][i][j]&&ans<j)
          ans=j;
    cout<<ans<<endl;
    //  Output

return 0;
}

lee1r 2010-10-29 22:50 发表评论

tyvj P1023 奶牛的锻炼

lee1r — Fri, 22 Oct 2010 06:43:00 GMT

定义状态d[i,j]表示进行到第i秒（还未对第i秒进行决策），疲倦程度为j之后，能够获得的最大距离。
第i秒有两种决策：继续跑、休息（注意到即使当前疲倦程度为0也是可以休息的），这样，
d[i,j]=max{ d[i+1,j+1]+r[i] (j+1<=m)
d[i+(j==0?1:j),0] (i+(j==0?1:j)<=n+1) }
以下是我的代码：

#include<iostream>
#include<string.h>
#define maxn 2002
#define maxm 501
#define inf 200000007
using namespace std;
long max(long a,long b){return (a>b?a:b);}

long n,m,r[maxn],d[maxn][maxm];

long dp(long i,long j)
{
    if(d[i][j]!=-1) return d[i][j];
    d[i][j]=-inf;
    if(j+1<=m)
        d[i][j]=max(d[i][j],dp(i+1,j+1)+r[i]);
    if(i+(j==0?1:j)<=n+1)
        d[i][j]=max(d[i][j],dp(i+(j==0?1:j),0));
    return d[i][j];
}

int main()
{
    cin>>n>>m;
    for(long i=1;i<=n;i++)
        cin>>r[i];
    //  Input

    memset(d,-1,sizeof(d));
    d[n+1][0]=0;
    for(long i=1;i<=m;i++)
        d[n+1][i]=-inf;
    //  Init

    cout<<dp(1,0)<<endl;
    //  DP & Output
return 0;
}

lee1r 2010-10-22 14:43 发表评论

tyvj P1024 外星人的密码数字

lee1r — Thu, 21 Oct 2010 17:14:00 GMT

DP，最长不下降子序列。
Here is my code:

#include<iostream>
#include<string>
#include<string.h>
#define maxn 307
using namespace std;

string rkey,s;

long f(char ch)
{
    for(long i=0;i<26;i++)
        if(rkey.at(i)==ch)
            return i;
    return 0;
}

int main()
{
    cin>>rkey;
    while(cin>>s)
    {
        long len=s.length(),ans,r[maxn],d[maxn];
        for(long i=1;i<=len;i++)
            r[i]=f(s.at(i-1));
        for(long i=1;i<=len;i++)
            d[i]=1;
        for(long i=1;i<=len;i++)
            for(long j=1;j<i;j++)
                if(r[j]<=r[i]&&d[j]+1>d[i])
                    d[i]=d[j]+1;
        ans=0;
        for(long i=1;i<=len;i++)
            if(ans<d[i])
                ans=d[i];
        cout<<ans;
    }
    cout<<endl;
return 0;
}

lee1r 2010-10-22 01:14 发表评论

tyvj P1015 公路乘车

lee1r — Mon, 18 Oct 2010 07:16:00 GMT

完全背包问题。
以下是我的代码：

#include<iostream>
#define maxn 107
#define maxm 17
#define inf 20000007
using namespace std;
long min(long a,long b){return (a<b?a:b);}

long n,w[maxm],c[maxm],d[maxn];

int main()
{
    for(long i=1;i<=10;i++)
    {
        cin>>c[i];
        w[i]=i;
    }
    cin>>n;
    //  Input

    d[0]=0;
    for(long i=1;i<=n;i++)
        d[i]=inf;
    for(long i=1;i<=10;i++)
        for(long j=w[i];j<=n;j++)
            d[j]=min(d[j],d[j-w[i]]+c[i]);
    //   DP

    cout<<d[n]<<endl;
    //  Output
return 0;
}

lee1r 2010-10-18 15:16 发表评论

树型动态规划之道路重建

lee1r — Mon, 11 Oct 2010 14:47:00 GMT

题目描述
农夫John的农场有n（n<=150）个牛舍，有些牛舍之间有双向道路连接，而每两个牛舍之间有且仅有一条道路（因此可以表示成一棵树）。由于任意一场地震都很可能让John的农场变得不连通，因此John希望估计一下，至少需要毁坏多少条道路才会让一个恰好有p（p<=n）个牛舍的子树脱离其他牛舍。

此题采用树型动态规划求解。
1、建树
由于一个结点可能会有多个子结点，给下面的动态规划带来不便，所以采用“左儿子右兄弟”表示法。
2、状态定义
定义d(i,j)表示在i结点上选取它的儿子或右边的兄弟或右边的兄弟的兄弟……共j个（包含自身）至少需要毁坏的道路数。
3、状态转移方程
考虑几种决策：
i结点连同所有儿子结点都舍弃不用：d(i,j)=d(R(i),j)+1；
i结点由包含k个结点的左子树和j-k-1个结点的右子树组成：d(i,j)=d(L(i),k)+d(R(i),j-k-1)；
4、边界条件
为了方便处理，如果一个结点没有左儿子或右儿子（在转换之后的二叉树中），那么它的左儿子或右儿子为0号结点。
那么边界可以是：
d(0,0)=0；
d(0,i)=INF,1<=i<=n；
我觉得这种表示还是很巧妙的。
注意，即使以i结点为根的数左子树为空，也不一定毁坏一条道路就能剪掉整个左子树，因为这是转换了之后的二叉树，原树上i结点可能有众多子结点。
5、最优解
在d(L(i),p-1)+(i==root?0:1)中找最优解。因为如果i是根节点，不需要毁坏任何道路。

以下是我的代码：

#include<fstream>
#include<string.h>
#define maxn 157
#define INF 20000007
using namespace std;
long min(long a,long b){return (a<b?a:b);}

typedef struct
{
    long ls,rs;
}treenode;

long n,p,root,ans,father[maxn],d[maxn][maxn];
treenode tree[maxn];

void Insert(long u,long v)
{
    if(!tree[u].ls)
        tree[u].ls=v;
    else
    {
        long p;
        for(p=tree[u].ls;tree[p].rs;p=tree[p].rs);
        tree[p].rs=v;
    }
}

long dp(long i,long j)
{
    if(d[i][j]!=-1) return d[i][j];
    d[i][j]=dp(tree[i].rs,j)+1;
    for(long k=0;j-k-1>=0;k++)
        d[i][j]=min(d[i][j],dp(tree[i].ls,k)+dp(tree[i].rs,j-k-1));
    return d[i][j];
}

int main()
{
    ifstream fin("roads.in");ofstream fout("roads.out");

    memset(tree,0,sizeof(tree));
    memset(father,0,sizeof(father));
    fin>>n>>p;
    for(long i=1;i<=n-1;i++)
    {
        long u,v;
        fin>>u>>v;
        Insert(u,v);
        father[v]=u;
    }
    //  Input

    memset(d,-1,sizeof(d));
    for(long i=1;i<=n;i++)
        d[0][i]=INF;
    d[0][0]=0;
    //  Init

    for(long i=1;i<=n;i++)
        if(!father[i])
            root=i;
    //  Find root

    ans=INF;
    for(long i=1;i<=n;i++)
      ans=min(ans,dp(tree[i].ls,p-1)+(i==root?0:1));
    fout<<ans<<endl;
    //  Output

    fin.close();fout.close();
return 0;
}

lee1r 2010-10-11 22:47 发表评论

Ural 1018 A Binary Apple Tree

lee1r — Sun, 12 Sep 2010 05:19:00 GMT

Tree_DP。
要注意到树枝上的苹果个数有可能是0个，所以一开始构图的时候不能用g[i][j]==0表示结点i和j之间没有边。
以下是我的代码：

#include<iostream>
#include<string.h>
#define maxn 107
#define max(a,b) (a>b?a:b)
using namespace std;
struct
{
    long l,r;
}tree[maxn];
long n,m,g[maxn][maxn],d[maxn][maxn];
bool used[maxn];

void build_tree(long node)
{
    bool first=true;
    used[node]=true;
    for(long i=1;i<=n;i++)
        if(!used[i]&&g[node][i]!=-1)
        {
            if(first)
            {
                tree[node].l=i;
                first=false;
            }
            else
                tree[node].r=i;
            build_tree(i);
        }
}
long dp(long i,long j)
{
    if(d[i][j]!=-1) return d[i][j];
    d[i][j]=0;
    d[i][j]=max(dp(tree[i].l,j-1)+g[i][tree[i].l],dp(tree[i].r,j-1)+g[i][tree[i].r]);
    for(long k=0;j-k-2>=0;k++)
        d[i][j]=max(d[i][j],dp(tree[i].l,k)+dp(tree[i].r,j-k-2)+g[i][tree[i].l]+g[i][tree[i].r]);
    return d[i][j];
}
int main()
{
    /*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/
    cin>>n>>m;
    memset(g,-1,sizeof(g));
    for(long i=1;i<=n-1;i++)
    {
        long a,b,w;
        cin>>a>>b>>w;
        g[a][b]=g[b][a]=w;
    }
    //  Input
    memset(tree,0,sizeof(tree));
    memset(used,false,sizeof(used));
    build_tree(1);
    //  Build Tree

    /*
    for(long i=1;i<=n;i++)
        cout<    //*/

    for(long i=0;i<=n;i++)
        for(long j=0;j<=n;j++)
            d[i][j]=-1;
    for(long i=0;i<=n;i++)
        d[0][i]=d[i][0]=0;
    //  Init
    cout<<dp(1,m)<<endl;
    //  Dp & Output
return 0;
}

lee1r 2010-09-12 13:19 发表评论

Ural 1017 The Staircases

lee1r — Sat, 11 Sep 2010 09:45:00 GMT

首先一眼看出是DP。先不考虑“每个楼梯至少有2格”这个条件，因为加上这个条件之后DP就不满足无后效性了；另外只有1格的情况只有一种，算出全部的之后再减去即可。
这样，d[i][j]表示当前楼梯共用了i块砖，且最后一格共j个砖的方案数，则：
d[0][0]=1
d[i][j]=sum{ d[i-j][k],0<=k以下是我的代码：

#include<iostream>
#include<string.h>
#define maxn 507
using namespace std;
long long n,ans,d[maxn][maxn];
int main()
{
    cin>>n;
    memset(d,0,sizeof(d));
    d[0][0]=1;
    for(long i=1;i<=n;i++)
        for(long j=1;j<=i;j++)
            for(long k=0;k<=j-1;k++)
                d[i][j]+=d[i-j][k];
    ans=0;
    for(long i=1;i<=n;i++)
        ans+=d[n][i];
    ans-=1;
    cout<<ans<<endl;
return 0;
}

lee1r 2010-09-11 17:45 发表评论

Ural 1012 K-based numbers. Version 2

lee1r — Fri, 10 Sep 2010 05:57:00 GMT

和Ural 1009一样，不过需要用到高精度，而且规模比之前大了不少，用了记忆化。
一开始测试数据的时候试了一个“10 170”的数据，发现结果很小，以为开100的数组应该够了。后来才发现我n和k弄反了！WA了一次！
给出“170 10”这个数据的结果，共170位。可以与自己的结果进行比对：
19140929114881653462
47604168411662739155
92368455809094944920
16732196087599513580
59650868133939742570
53930574840609094661
65965897483835868175
67975397667274771543
2612675930
以下是我的代码：

#include<iostream>
#include<string.h>
#define max_digit 177
#define maxn 187
using namespace std;
typedef struct
{
    long n,s[max_digit];
}bign;
const bign nil={1,{-1}};
long n,k;
bign d[maxn][2];

void Add(bign &c,bign &a,bign &b)
{
    memset(c.s,0,sizeof(c.s));
    c.n=(a.n>b.n?a.n:b.n);
    for(long i=0;i<c.n;i++)
    {
        c.s[i]+=a.s[i]+b.s[i];
        if(c.s[i]>=10)
        {
            c.s[i]-=10;
            c.s[i+1]++;
        }
    }
    if(c.s[c.n]) c.n++;
}
void Mul(bign &c,long t,bign &a)
{
    memset(c.s,0,sizeof(c.s));
    c.n=a.n;
    for(long i=0;i<c.n;i++)
        c.s[i]=t*a.s[i];
    for(long i=0;i<c.n;i++)
        if(c.s[i]>=10)
        {
            c.s[i+1]+=c.s[i]/10;
            c.s[i]%=10;
        }
    if(c.s[c.n]) c.n++;
}
void Print(bign &a)
{
    for(long i=a.n-1;i>=0;i--)
        cout<<a.s[i];
}

void dp(long i,long j)
{
    if(d[i][j].n!=1||d[i][j].s[0]!=-1) return;
    if(i==1)
    {
        dp(i+1,1);
        Mul(d[i][j],k-1,d[i+1][1]);
        return;
    }
    if(i==n)
    {
        if(j)
        {d[i][j].n=1;d[i][j].s[0]=k;}
        else
        {d[i][j].n=1;d[i][j].s[0]=k-1;}
        return;
    }
    if(j)
    {
        bign t;
        dp(i+1,1);Mul(t,k-1,d[i+1][1]);
        dp(i+1,0);Add(d[i][j],t,d[i+1][0]);
    }
    else
    {
        dp(i+1,1);
        Mul(d[i][j],k-1,d[i+1][1]);
    }
}
int main()
{
    /*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/
    cin>>n>>k;
    for(long i=0;i<=n;i++)
        d[i][0]=d[i][1]=nil;
    dp(1,1);
    Print(d[1][1]);
    cout<<endl;
return 0;
}

lee1r 2010-09-10 13:57 发表评论

Ural 1002 Phone numbers

lee1r — Tue, 15 Jun 2010 14:11:00 GMT

说来惭愧！自从省选之后自己就没有再碰过程序，最近重新开始。这道非常简单的DP竟然没有看出来！原因应该是没有审清题目……没有注意到“shortest”，直接搜出一组解就输出了……
很简单的DP，不多解释，d[i]=min{d[i],d[i-l[j]]+1}。
另外注意，一个单词可以使用多次。
以下是我的代码：

#include<iostream>
#include<string>
#include<string.h>
using namespace std;
const long maxl=107,maxn=50007,INF=20000007;
const string END_CMD="-1";
const long ff[27]={2,2,2,3,3,3,4,4,1,1,5,5,6,6,0,7,0,7,7,8,8,8,9,9,9,0};

long n,nlen,a[maxl];
long r[maxn][maxl/2],l[maxn];
long d[maxl],f[maxl];
string str[maxn];

bool ok(long ii,long jj)
{
    for(long i=ii-l[jj]+1,j=1;i<=ii;i++,j++)
        if(a[i]!=r[jj][j])
            return false;
    return true;
}
int main()
{
    /*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/
    string tmp;
    while(cin>>tmp&&tmp!=END_CMD)
    {
        nlen=tmp.length();
        for(long i=1;i<=nlen;i++) a[i]=(long)(tmp[i-1]-'0');
        cin>>n;
        for(long i=1;i<=n;i++)
        {
            cin>>str[i];
            l[i]=str[i].length();
            for(long j=1;j<=l[i];j++) r[i][j]=ff[str[i][j-1]-'a'];
        }
        //  Input & Init
        for(long i=0;i<=nlen;i++) d[i]=INF;
        for(long i=0;i<=nlen;i++) f[i]=0;
        d[0]=0;
        for(long i=1;i<=nlen;i++)
            for(long j=1;j<=n;j++)
                if(i>=l[j]&&ok(i,j)&&d[i-l[j]]+1<d[i])
                {
                    d[i]=d[i-l[j]]+1;
                    f[i]=j;
                }
        if(d[nlen]>=INF)
            cout<<"No solution."<<endl;
        else
        {
            long s=0,ans[maxl];
            long i=nlen;
            while(f[i])
            {
                s++;ans[s]=f[i];
                i-=l[f[i]];
            }
            for(long i=s;i>=1;i--)
            {
                if(i<s) cout<<" ";
                cout<<str[ans[i]];
            }
            cout<<endl;
        }
    }
return 0;
}

代码可能写得有点乱，两个月没写代码了……

lee1r 2010-06-15 22:11 发表评论

NOIP 2006 过河

lee1r — Mon, 08 Mar 2010 11:40:00 GMT

如果两个点之间的距离大于t^2，就另他们之间的距离为t^2。如果s!=t，且距离大于t^2，一定存在一种走法，可以从前一个点走到下一个点。
以下是我的代码：

#include<stdio.h>
#include<string.h>
#define maxm 107
#define maxl 15007
#define INF 2000007
#define min(a,b) (a
long l,s,t,m,pos[maxm],d[maxl];
bool a[maxl];
void swap(long &a,long &b)
{
    long t=a;a=b;b=t;
}
void Qsort(long *a,long begin,long end)
{
    long i=begin,j=end,mid=a[(begin+end)/2];
    do{
         while(a[i]<mid) i++;
         while(a[j]>mid) j--;
         if(i<=j)
         {
            swap(a[i],a[j]);
            i++;j--;
         }
    }while(i<=j);
    if(begin<j) Qsort(a,begin,j);
    if(i<end)   Qsort(a,i,end);
}
int main()
{
    /*
    freopen("river.in","r",stdin);
    freopen("river.out","w",stdout);
    //*/
    scanf("%ld%ld%ld%ld",&l,&s,&t,&m);
    pos[0]=0;
    for(long i=1;i<=m;i++)
      scanf("%ld",&pos[i]);
    if(s==t)
    {
       long ans=0;
       for(long i=1;i<=m;i++)
         if(pos[i]%s==0)
           ans++;
       printf("%ld\n",ans);
       return 0;
    }
    Qsort(pos,0,m);
    memset(a,false,sizeof(a));
    for(long i=1;i<=m;i++)
    {
       if(pos[i]-pos[i-1]>=t*t)
       {
          long tmp=pos[i]-(pos[i-1]+t*t);
          pos[i]=pos[i-1]+t*t;
          for(long j=i+1;j<=m;j++)
            pos[j]-=tmp;
       }
       a[pos[i]]=true;
    }
    l=pos[m]+t*t;
    for(long i=1;i<=l;i++) d[i]=INF;
    d[0]=0;
    for(long i=s;i<=l;i++)
      for(long j=s;j<=t;j++)
        d[i]=min(d[i],d[i-j]+a[i]);
    printf("%ld\n",d[l]);
return 0;
}

lee1r 2010-03-08 19:40 发表评论

UVa 116 Unidirectional TSP

lee1r — Mon, 01 Mar 2010 13:30:00 GMT

以下是我的代码：

#include<stdio.h>
#define maxn 107
#define INF 20000000
long m,n,ans,pos,a[maxn][maxn],d[maxn][maxn],f[maxn][maxn];
int main()
{
    while(scanf("%ld%ld",&m,&n)==2)
    {
       for(long i=1;i<=m;i++)
         for(long j=1;j<=n;j++)
           scanf("%ld",&a[i][j]);
       for(long i=0;i<=m+1;i++)
         for(long j=0;j<=n+1;j++)
         {
            d[i][j]=INF;
            f[i][j]=-1;
         }
       for(long i=0;i<=m+1;i++)
         d[i][n+1]=0;
       for(long i=n;i>=1;i--)
         for(long j=1;j<=m;j++)
           if(j==1)
           {
              if(d[1][i]>d[1][i+1])
              {d[1][i]=d[1][i+1];f[1][i]=1;}
              if(d[1][i]>d[2][i+1])
              {d[1][i]=d[2][i+1];f[1][i]=2;}
              if(d[1][i]>d[m][i+1])
              {d[1][i]=d[m][i+1];f[1][i]=m;}
              d[1][i]+=a[1][i];
           }
           else if(j==m)
           {
              if(d[j][i]>d[1][i+1])
              {d[j][i]=d[1][i+1];f[j][i]=1;}
              if(d[j][i]>d[j-1][i+1])
              {d[j][i]=d[j-1][i+1];f[j][i]=j-1;}
              if(d[j][i]>d[j][i+1])
              {d[j][i]=d[j][i+1];f[j][i]=j;}
              d[j][i]+=a[j][i];
           }
           else
           {
              if(d[j][i]>d[j-1][i+1])
              {d[j][i]=d[j-1][i+1];f[j][i]=j-1;}
              if(d[j][i]>d[j][i+1])
              {d[j][i]=d[j][i+1];f[j][i]=j;}
              if(d[j][i]>d[j+1][i+1])
              {d[j][i]=d[j+1][i+1];f[j][i]=j+1;}
              d[j][i]+=a[j][i];
           }
       ans=INF;
       for(long i=1;i<=m;i++)
         if(d[i][1]<ans)
         {
            ans=d[i][1];
            pos=i;
         }
       bool first=true;
       for(long i=1;i<=n;i++)
       {
          if(first) first=false;
          else printf(" ");
          printf("%ld",pos);
          pos=f[pos][i];
       }putchar('\n');
       printf("%ld\n",ans);
    }
return 0;
}

lee1r 2010-03-01 21:30 发表评论

UVa 674 Coin Change

lee1r — Mon, 01 Mar 2010 11:39:00 GMT

题目大意：给出1分、5分、10分、25分、50分这5种硬币，求：有多少种方法可以组合成为钱数N。
自我感觉还是比较喜欢记忆化搜索的，一个最大的好处就是不计算不需要的状态，需要多少计算多少！
以下是我的代码：

#include<stdio.h>
#include<string.h>
#define maxn 7500
const long coin[]={0,1,5,10,25,50};
long n,d[maxn][6];
long dp(long s,long k)
{
    if(d[s][k]!=-1) return d[s][k];
    d[s][k]=0;
    for(long i=k;i<=5&&s>=coin[i];i++)
      d[s][k]+=dp(s-coin[i],i);
    return d[s][k];
}
int main()
{
    memset(d,-1,sizeof(d));
    for(long i=0;i<=5;i++) d[0][i]=1;
    while(scanf("%ld",&n)==1)
      printf("%ld\n",dp(n,1));
return 0;
}

lee1r 2010-03-01 19:39 发表评论

UVa 10405 Longest Common Subsequence

lee1r — Mon, 01 Mar 2010 11:12:00 GMT

最近练习动态规划，很经典的一个问题，也很基础。
以下是我的代码：

#include<stdio.h>
#include<string.h>
#define maxn 1007
#define max(a,b) (a>b?a:b)
char a[maxn],b[maxn];
long lena,lenb,d[maxn][maxn];
int main()
{
    while(gets(a)&&gets(b))
    {
       lena=strlen(a);
       lenb=strlen(b);
       memset(d,0,sizeof(d));
       for(long i=1;i<=lena;i++)
         for(long j=1;j<=lenb;j++)
         {
            d[i][j]=max(d[i-1][j],d[i][j-1]);
            if(a[i-1]==b[j-1])
              d[i][j]=max(d[i][j],d[i-1][j-1]+1);
         }
       printf("%ld\n",d[lena][lenb]);
    }
return 0;
}

lee1r 2010-03-01 19:12 发表评论

UVa 10154 Weights and Measures

lee1r — Mon, 22 Feb 2010 08:26:00 GMT

题目中没有给出重量和力量的范围，这似乎实在提醒我们：状态只和乌龟的个数有关！
a[i]为n个乌龟的重量，b[i]为n个乌龟的力量，定义d[i,j]表示从前i个乌龟中挑选出j个乌龟，j个乌龟的最小重量和为d[i,j]，这样就有如下状态转移方程：d[i,j]=min{d[i-1,j],d[i-1,j-1]+a[i]}(i>=j时状态有效，其中第二个转移方式的条件为d[i-1,j-1]<=b[i]-a[i])。
现在又有一个问题，题目中给出的序列是散乱的，无法保证最优子结构，所以要按照b[i]-a[i]递增的顺序排序。至于为什么要这么排序，我的认为是：只有这样才能使递推进行下去，试想如果不是这样，如何递推呢？
以下是我的代码：

#include<stdio.h>
#define maxn 5610
#define INF 10000000
#define min(a,b) (a
long n=0,ans=0,a[maxn],b[maxn],d[maxn][maxn];
void Qsort(long begin,long end)
{
    long i=begin,j=end,mid=b[(begin+end)/2],t;
    do{
         while(b[i]<mid) i++;
         while(b[j]>mid) j--;
         if(i<=j)
         {
            t=a[i];a[i]=a[j];a[j]=t;
            t=b[i];b[i]=b[j];b[j]=t;
            i++;j--;
         }
    }while(i<=j);
    if(begin<j) Qsort(begin,j);
    if(i<end)   Qsort(i,end);
}
int main()
{
    while(scanf("%ld%ld",&a[n+1],&b[n+1])==2)
    {
       n++;b[n]-=a[n];
    }
    //  Read In
    Qsort(1,n);
    //  Sort
    for(long i=0;i<=n;i++)
      for(long j=0;j<=n;j++)
        d[i][j]=INF;
    for(long i=0;i<=n;i++)
      d[i][0]=0;
    //  Init
    for(long i=1;i<=n;i++)
      for(long j=1;j<=i;j++)
      {
         d[i][j]=min(d[i][j],d[i-1][j]);
         if(d[i-1][j-1]<=b[i])
            d[i][j]=min(d[i][j],d[i-1][j-1]+a[i]);
      }
    //  DP
    for(long i=n;i>=1;i--)
      if(d[n][i]<INF)
      {
         ans=i;
         break;
      }
    printf("%ld\n",ans);
return 0;
}

lee1r 2010-02-22 16:26 发表评论

UVa 10271 Chopsticks

lee1r — Fri, 19 Feb 2010 13:01:00 GMT

我很少写较长的题解，但是对于这一题我觉得很有必要。
对于这道题，首先应该想到贪心：每次取差值最小的一对。但是这样的贪心策略很容易找到反例，而且N=5000的数据规模，十分有可能是O(n^2)的算法。
于是考虑动态规划。如果是DP，那么很容易想到如下的状态定义：d[i][j]表示用前j个数组成i个(x,y,z)数对的最小消耗。
另外一个很容易注意到的地方就是：对于一个最优决策中的任意一个数对(x,y,z)，其中x和y必在有序的a[i]中相邻。关于这点用反证法不难证明，也很容易注意到。
对于(x,y,z)中的z应该如何决策的问题，之前一直令我迷惑，这一点应该是题目最难解决的问题。

考虑状态d[i][j]:
    对于x和y，有如下考虑：
        对于a[j]，如果不使用a[j]，那么d[i][j]=d[i][j-1]；
        如果使用a[j]，那么就和a[j-1]一起使用，d[i][j]=d[i-1][j-2]+w(a[i],a[i-1])；
    于是有了总的状态转移方程：d[i][j]=min{d[i][j-1],d[i-1][j-2]+w(a[i],a[i-1])}；
    这应该不难理解，但是对于z的决策呢？
    如果把a[i]按降序排列，那么z的影响就可以忽略了！这样依然可以采用上面的方程。

考虑状态d[i][j]：
    如果j<3i，此时当前策略是不可行的，d[i][j]=INF；
    如果j>=3i，即j>=3(i-1)+3，j>3(i-1)+2，当前状态有效
        转移到d[i-1][j-2]时，至少剩余一个多余的a[k]
        由于序列降序，a[k]可以和a[j]、a[j-1]配对
       同时d[i-1][j-2]有效，可以继续递归。
        转移到d[i][j-1]
        若d[i][j-1]为无效状态，d[i][j-1]==INF，必然不会比上面那种转移方式优；
        若d[i][j-1]为有效状态，可以继续递归地进行下去。

以下是我的代码，采用的记忆化搜索：

#include<stdio.h>
#include<string.h>
const long maxn=5007,INF=100000007;
long k,n,r[maxn],d[1007][maxn],w[maxn];
long min(long a,long b)
{
    return (a<b?a:b);
}
void swap(long &a,long &b)
{
    long t=a;a=b;b=t;
}
long dp(long kk,long nn)
{
    if(d[kk][nn]!=-1)
        return d[kk][nn];
    if(nn<3*kk)
        d[kk][nn]=INF;
    else if(kk==0)
        d[kk][nn]=0;
    else
    {
        d[kk][nn]=INF;
        d[kk][nn]=min(dp(kk,nn-1),dp(kk-1,nn-2)+w[nn]);
    }
    return d[kk][nn];
}
int main()
{
    /*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/
    long test;
    scanf("%ld",&test);
    while(test--)
    {
        scanf("%ld%ld",&k,&n);k+=8;
        for(long i=1;i<=n;i++)
            scanf("%ld",&r[i]);
        //  Input
        for(long i=1,j=n;i<j;i++,j--)
            swap(r[i],r[j]);
        for(long i=2;i<=n;i++)
            w[i]=(r[i]-r[i-1])*(r[i]-r[i-1]);
        for(long i=0;i<=k;i++)
            for(long j=0;j<=n;j++)
                d[i][j]=-1;
        //  Init
        //  DP
        printf("%ld\n",dp(k,n));
    }
return 0;
}

lee1r 2010-02-19 21:01 发表评论