C++博客-yzhw@ujs code my life~-随笔分类-DP

pku3903 最长递增字串的单调性优化

yzhw — Thu, 09 Feb 2012 11:33:00 GMT

好久不动题目了，今天动了一题，忒背运，死都TLE，想了想，算法复杂度没问题啊，n=100000，nlogn的算法拼1S的RP咋崩溃的。。后来想起了无敌的POJ超级慢速set，无奈，不想改，到处搜有这题的OJ，TOJ上跑了下，10MS。。汗。。下载数据数据来看了看，就是12组，就是本地debug也不会TLE啊。。没办法。。
不发牢骚了，说说这题的方法吧。
一般的最长递增字串用n^2做很好做，就是dp[i]=max{dp[j]+1,height[j]首先，我们知道，要维护这样一个单调队列，当height[i]那么更新过的DP方程就是
dp[i]=dp[j]+1,j为满足height[j]然后更新单调队列的策略是把当前决策加入单调队列里，然后往后删除dp[i]>=dp[j]并且height[i]每个元素最多入队一次，出队一次，所以总得复杂度o(nlogn)
我是全部用set实现的，轻松好省

1 # include
2 # include <set>
3 using namespace std;
4 struct node
5 {
6    int height,id;
7    node(int h,int i):height(h),id(i){}
8    bool operator<(const node &pos) const
9    {
10        if(height!=pos.height) return height11        else return id12    }
13 };
14 set q;
15 int dp[100005];
16 int main()
17 {
18      int n;
19      while(scanf("%d",&n)!=EOF)
20      {
21         q.clear();
22         for(int i=0;i23         {
24             int t;
25             scanf("%d",&t);
26             set::iterator it=q.lower_bound(node(t,-1));
27             int ans;
28             if(it==q.begin())
29               ans=1;
30             else
31               ans=dp[(--it)->id]+1;
32             it=q.lower_bound(node(t,-1));
33             if(it!=q.end()&&it->height==t)
34                  it=q.erase(it);
35             while(it!=q.end()&&dp[it->id]<=ans)
36                  it=q.erase(it);
37             q.insert(node(t,i));
38             dp[i]=ans;
39         }
40         printf("%d\n",dp[q.rbegin()->id]);
41      }
42      return 0;
43 }
44

yzhw 2012-02-09 19:33 发表评论

pku 3998 Land Division DP斜率优化

yzhw — Mon, 17 Oct 2011 18:17:00 GMT

摘要: 题意：n个点，用水平线或者竖直线划分成k条，要求平均差最小，平均差为每条中点的个数减去n/k的绝对值。解法：首先一看就是个DP，与处理不说了，用水平扫描线、竖直扫描线将同一直线上的点压缩成一个带权值的点，然后DP这题重要的是DP降维观察DP方程dp[i]=min{dp[j]+|sum[i]-sum[j]-average|}这里就要分成两部分讨论1、当sum[i]-sum[j]>average... 阅读全文

yzhw 2011-10-18 02:17 发表评论

The 36th ACM/ICPC Asia Regional Dalian Online Contest 大连2011ICPC网络赛个人题解

yzhw — Sun, 04 Sep 2011 02:42:00 GMT

摘要: 好久不写题，外加上在准备考研，这次有点悲剧，比赛时A了5题，还有一题有点小BUG，比赛后才A。。今年要考南京大学~也没时间准备ICPC了，希望我们队里的那个小孩子能够快快成长起来，我这个队长也可以安心的卸任了，明年将最后一次比赛机会放在NJU吧~恩，顺便去看下高中膜拜过的蒋炎研同学~江苏大学加油！第一题：其实就是构建一个DAG，然后再DAG上求最长路径。要注意构图时候避免环，特别考虑当两个木块长宽... 阅读全文

yzhw 2011-09-04 10:42 发表评论

pku3124 The Bookcase 扩展背包好题

yzhw — Sun, 31 Jul 2011 13:20:00 GMT

题意：
一堆书，每本书都有厚度和高度，管理员试图将这些书放到三层的书架上，每层都不能为空，求书架最小体积（书架深度显然为所有书深度最大值，所以与排放方案无关，故取1）.
体积公式：
解题思想：
大概思路是DP，这个要先定下来
设v=(f(s1)+f(s2)+f(s3))*max{g(s1),g(s2),g(s3)}
其中g(s3)=SUM-g(s1)-g(s2)
f(s3)=max(h_i)
就说说，我们有4个决策变量
一个变量留给DP决策，另一个变量利用DP状态设计来消除（这就需要对初始数据排序，保证决策过程中h_i<=h_p2,i属于s2,p2为当前决策点）。
这个问题就转化为在一个有序队列上选择两个分割点p1,p2，h_p1p2,使得max{hi,i属于s1}状态可以设计为
F(i,t₁,t₂)
即考虑到第i个元素，s1的总厚度为t1,s2的总厚度为t2时p1所在元素的高度的最小值。
F（i,t1,t2)=min(F(i-1,t1,t2-data[i].t),data[i].h(当F(i-1,t1-data[i].t,t2)合法时),F(i-1,t1,t2))，显然，三个转移意义分别为将当前元素分配给s2、s1、s3
当F(i,t1,t2)由F(i-1,t1,t2-data[i].t)转移过来的时候试图更新全局最优解ans=min(ans,(data[i].h+F(i,t1,t2)+data[n-1].h)*t1*t2*(t_total-t1-t2))。注意，这里说F(i,t1,t2)由F(i-1,t1,t2-data[i].t)转移过来指的是F(i-1,t1,t2-data[i].t)<=min(data[i].h(当F(i-1,t1-data[i].t,t2)合法时),F(i-1,t1,t2)),等于不能丢掉（原因？只有此时才能更新全局最优解）
代码如下

yzhw 2011-07-31 21:20 发表评论

pku1202 Family DAG图上的概率DP

yzhw — Sat, 05 Feb 2011 12:59:00 GMT

题意：
给出N个怪物的家谱树，求M对怪物间的相关度。怪物可能一夫多妻或一妻多夫，也可以隔代交配。

给力条件：DAG

解法：
众所周知，DP有两种推理方法：第i个状态能推出哪些状态以及第i个状态可以由哪些状态得出，本题必须使用第二种方案
dp[pos][i],i=1..n为第pos个节点与其前趋（包括间接）节点间的相关度。
状态转移即为dp[pos][i]=sum(dp[p][i]*0.5),p为pos的直接前驱趋节点。
这题POJ好诡异，死都过不去，但是在小poj(poj.grids.cn)，和zju上都没问题。可能将递归改成拓扑序上的迭代就可以了。不过我懒，不想动- -

代码：

1import java.io.*;
2import java.util.*;
3import java.math.*;
4public class Main {
5    static int nxt[][]=new int[305][305];
6    static BigDecimal dp[][]=new BigDecimal[305][305],two=BigDecimal.ONE.add(BigDecimal.ONE);
7    static int n=0,m=0;
8    static boolean used[]=new boolean[305];
9    static StreamTokenizer in=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
10    static int nextInt() throws IOException
11    {
12        in.nextToken();
13        return (int)in.nval;
14    }
15    static void dfs(int pos)
16    {
17        if(used[pos]) return;
18        used[pos]=true;
19
20        for(int j=0;j<2&&nxt[pos][j]!=-1;j++)
21        {
22            int p=nxt[pos][j];
23            dfs(p);
24            for(int i=1;i<=n;i++)  {dp[pos][i]=dp[pos][i].add(dp[p][i].divide(two));dp[i][pos]=dp[pos][i];}
25        }
26        dp[pos][pos]=BigDecimal.ONE;
27    }
28    public static void main(String[] args) throws IOException{
29        n=nextInt();
30         m=nextInt();
31        nxt=new int[n+1][2];
32        used=new boolean[n+1];
33        dp=new BigDecimal[n+1][n+1];
34        for(int i=1;i<=n;i++)
35        {
36            Arrays.fill(dp[i],BigDecimal.ZERO);
37            Arrays.fill(nxt[i],-1);
38        }
39        Arrays.fill(used, false);
40        for(int i=0;i<m;i++)
41        {
42            int a=nextInt(),b=nextInt(),c=nextInt();
43            nxt[a][0]=b;
44            nxt[a][1]=c;
45        }
46        for(int i=1;i<=n;i++)
47            dfs(i);
48       m=nextInt();
49       for(int i=0;i<m;i++)
50       {
51           int a=nextInt(),b=nextInt();
52          System.out.println(dp[a][b].multiply(new BigDecimal("100")).stripTrailingZeros().toPlainString()+"%");
53       }
54    }
55}

yzhw 2011-02-05 20:59 发表评论

pku 1946 Cow Cycling 非常好的DP

yzhw — Fri, 04 Feb 2011 17:13:00 GMT

题意：
n头奶牛跑步，一个领跑，另外的跟跑。总距离是k，如果某一单位时间速度为v，则领队奶牛消耗v^2能量，其他奶牛消耗v能量。每头奶牛初始的能量相同。问奶牛们到达终点的最短时间。

解法:
其他不说了，重要的是第i个牛在哪几个时刻领队并不重要，重要的是领了多少个时间单位的队，下面状态就不难划分了吧？

代码：

1 # include <stdio.h>
2 # include <string.h>
3 # include <stdlib.h>
4 int dp[21][101][101],n,e,d;
5 int solve(int used,int e1,int e2)
6 {
7    if(e1<0||e2<0) return -1;
8     else if(used>=n) return -1;
9    else if(e-e2>=d)
10        return 0;
11    else if(dp[used][e1][e2]!=-1) return dp[used][e1][e2]==-2?-1:dp[used][e1][e2];
12    else
13    {
14       int i;
15       dp[used][e1][e2]=-2;
16       for(i=1;e1-i*i>=0;i++)
17          if(solve(used,e1-i*i,e2-i)!=-1&&(dp[used][e1][e2]==-2||solve(used,e1-i*i,e2-i)+1<dp[used][e1][e2]))
18             dp[used][e1][e2]=solve(used,e1-i*i,e2-i)+1;
19       for(i=1;e2-i*i>=0;i++)
20          if(solve(used+1,e2-i*i,e2-i)!=-1&&(dp[used][e1][e2]==-2||solve(used+1,e2-i*i,e2-i)+1<dp[used][e1][e2]))
21             dp[used][e1][e2]=solve(used+1,e2-i*i,e2-i)+1;
22
23       return dp[used][e1][e2]==-2?-1:dp[used][e1][e2];
24    }
25 }
26 int main()
27 {
28     scanf("%d%d%d",&n,&e,&d);
29     memset(dp,-1,sizeof(dp));
30     printf("%d\n",solve(0,e,e)==-1?0:solve(0,e,e));
31     //system("pause");
32     return 0;
33
34 }

yzhw 2011-02-05 01:13 发表评论

pku1948 Triangular Pastures DP+枚举。海伦公式

yzhw — Fri, 04 Feb 2011 17:02:00 GMT

题意
给出一些木棒，问能否用这些木棒拼成三角形，如果可能求最大的面积。

解法：
先给出一个定理：海伦公式

下面就是枚举边长。首先枚举最长边c，由于两边之和大于第三边，c的长度必须小于周长的一半，这是一个重要的剪枝。如果还要剪枝，可以先一次DP求得由木棍组合可以达到的长度。
确定c以后再枚举a，然后再次可以用DP验证木棒能否组合成a、c的长度。这里可以再一次剪枝，枚举c的时候建议从周长的一半向下枚举，原因很简单，尽量构造一个较优的合法解，根据海伦公式(p-a)(p-b)(p-c)，当c确定时最大值的位置也清楚了（b和c相等的位置，如果在最优位置（上限，可能达不到）都不能比最优解优，就直接cut）。然后下面就没什么难度了。

代码：

1 # include <cstdio>
2 # include <cstring>
3 # include <cstdlib>
4 # include <cmath>
5 using namespace std;
6 # include <algorithm>
7 bool dp[2][855][855];
8 int plen[1605],pc=0;
9 int n,len[41];
10
11 int main()
12 {
13     int total=0;
14     scanf("%d",&n);
15     for(int i=0;i<n;i++)
16     {
17       scanf("%d",len+i);
18       total+=len[i];
19     }
20     sort(len,len+n);
21     bool tmp[1606];
22     memset(tmp,false,sizeof(tmp));
23     memset(dp[0],0,sizeof(dp[0]));
24     dp[0][0][0]=true;
25     for(int i=1;i<=n;i++)
26     {
27       memset(dp[i%2],false,sizeof(dp[i%2]));
28       for(int j=0;j<=total/2+40;j++)
29         for(int k=j;k<=total/2+40;k++)
30            if(j-len[i-1]>=0&&dp[(i-1)%2][min(j-len[i-1],k)][max(j-len[i-1],k)]||
31               k-len[i-1]>=0&&dp[(i-1)%2][min(j,k-len[i-1])][max(k-len[i-1],j)]||
32               dp[(i-1)%2][j][k])
33               dp[i%2][j][k]=true;
34     }
35
36     tmp[len[0]]=true;
37     for(int i=1;i<n;i++)
38       for(int j=0;j<=total;j++)
39         if(tmp[j]&&j+len[i]<=total)
40           tmp[j+len[i]]=true;
41     for(int i=0;i<=total;i++)
42        if(tmp[i])
43           plen[pc++]=i;
44     int best=-1;
45     for(int c=lower_bound(plen,plen+pc,total/2)-plen-1;c>=0;c--)
46     {
47        int a=(total-plen[c])/2,b=total-plen[c]-a;
48        if(best!=-1&&(total-2*plen[c])*(total-2*a)*(total-2*b)<best) continue;
49        for(a=0;plen[a]<total-plen[c];a++)
50          if(plen[c]>=plen[a]&&plen[c]>=total-plen[a]-plen[c]&&dp[n%2][plen[a]][plen[c]]&&(best==-1||best<(total-2*plen[c])*(total-2*plen[a])*(total-2*(total-plen[a]-plen[c]))))
51              best=(total-2*plen[c])*(total-2*plen[a])*(total-2*(total-plen[a]-plen[c]));
52     }
53     if(best==-1) printf("-1\n");
54     else
55     {
56         best=(int)(sqrt(best*(double)total)*25+1e-6);
57         printf("%d\n",best);
58     }
59     //system("pause");
60     return 0;
61
62 }
63

yzhw 2011-02-05 01:02 发表评论

pku1335 Digital Onion 递归

yzhw — Mon, 24 Jan 2011 17:01:00 GMT

题意：
定义括号序列：
Definition: Null parenthesis is a DO. Especially, we call this the Null DO.
Definition: "( )" is a DO. Especially, we call this the primitive DO.
Definition: If both A and B are DOs, then the combined form of "(A)B" is also a DO, where we call A the inside of the DO and B the outside of the DO.
定义排序规则：
[Rule1]: The more weight, the more expensive.
[Rule2]: If the weights of two DOs are equal, then the price depends on the inside DO of the two DOs.
[Rule3]: If the weights of two DOs are the same and the prices of the inside DOs are equal, then the price depends on the outside DO of the two DOs.
给出一个符号序列，求这个之后的一个符号序列是什么

思路：
首先要确定最小的符号序列为：（）（）（）...
然后就是转化方法：
对于一个符号序列(inside)outside，首先看outside能否+1，不行的话看inside能否+1，同时将outside置为最小值形式，再不行的话当outside不为空的时候将inside的weight+1,outside's weight-1，将两部分都转化为最小值形式。
以上描述的是一个递归过程~当然，考虑一种特殊情况，如果整个式子无法进行+1操作，只能将整个式子的weight+1,然后化为最小值形式。

发现java的string竟然是值传递，非常的蛋疼。。我喜欢java的String，没办法，只好用C++的string。。。这种字符串处理的题目string是非常给力的~

代码：

1# include <iostream>
2# include <string>
3# include <cstring>
4using namespace std;
5string str;
6void make(int s,int e,int type)
7{
8    int c=0;
9    for(int i=s;i<e;i++)
10        if(str[i]=='(')
11            c++;
12    c+=type;
13    string res="";
14    for(int i=0;i<c;i++) res+="()";
15    str=str.substr(0,s)+res+str.substr(e,str.length()-e);
16}
17bool solve(int s,int e)
18{
19    if(s==e) return false;
20    else
21    {
22        int c=-1,end;
23        for(end=s+1;end<e&&c;end++)
24            switch(str[end])
25            {
26            case '(':c--;break;
27            case ')':c++;break;
28            };
29        if(solve(end,e)) return true;
30        else if(solve(s+1,end-1))
31        {
32            make(end,e,0);
33            return true;
34        }
35        else if(end!=e)
36        {
37            make(end,e,-1);
38            make(s+1,end-1,1);
39            return true;
40        }
41        else return false;
42    }
43}
44int main()
45{
46    int test;
47    cin>>test;
48    while(test--)
49    {
50        str.clear();
51        while(true)
52        {
53            string tmp;
54            cin>>tmp;
55            if(tmp=="$") break;
56            str+=tmp;
57        }
58        if(!solve(0,str.length())) make(0,str.length(),1);
59        for(int i=0;i<str.length();i++)
60            cout<<str[i]<<" ";
61        cout<<"$"<<endl;
62    }
63    return 0;
64}

yzhw 2011-01-25 01:01 发表评论

pku1332 Finding Liars DP 经典好题

yzhw — Sun, 23 Jan 2011 17:01:00 GMT

题意：

i (tester)	j (testee)/td>	test outcome a_i,j
truth-teller	truth-teller	0
truth-teller	liar	1
liar	truth-teller	0 or 1
liar	liar	0 or 1

不用说了吧

解法：
这题我开始往2-sat的方向去想，搞死了搞不出来，今天洗澡的时候忽然发现。。这题原来是一个水了不能再水的DP
首先，设置DP状态(pos,left,jud)，即决策到第pos个人时还允许有left个人是骗子，并且第pos个人是诚实的/骗子时的状态。
状态是一个集合，我用的bitset。
关于状态转移就很简单了
分2种情况：
1、第pos个人是骗子，那么第pos+1个人是诚实的或者骗子都可以
2、第pos个人是诚实的，那么第pos+1个人只能根据第pos个人说的话来决定
第一个人的情况要枚举，并且最后特别判断下
还有就是，集合初始化为全1，然后状态的运算是与运算。注意滚动数组，不然MLE到你哭~

代码：

1# include <cstdio>
2# include <cstring>
3# include <bitset>
4using namespace std;
5# define N 1005
6bitset<N> dp[2][N][2],one,zero;
7int data[N],n,maxnum;
8int main()
9{
10    int test;
11    scanf("%d",&test);
12    one.set();
13    zero.reset();
14    while(test--)
15    {
16        one.set();
17        zero.reset();
18        scanf("%d%d",&n,&maxnum);
19        for(int i=0;i<n;i++)
20            scanf("%d",data+i);
21        bitset<N> res=one;
22        for(int i=0;i<=maxnum;i++)
23            dp[0][i][0]=zero,dp[0][i][1]=one;
24        for(int i=1;i<=n;i++)
25        {
26            for(int j=0;j<=maxnum;j++)
27                dp[i%2][j][0]=dp[i%2][j][1]=one;
28            for(int j=0;j<=maxnum;j++)
29                dp[i%2][j][0]&=dp[(i-1)%2][j][1];
30            for(int j=0;j<maxnum;j++)
31                dp[i%2][j][1]&=dp[(i-1)%2][j+1][1].set(i);
32            if(!data[i-1])
33                for(int j=0;j<=maxnum;j++)
34                    dp[i%2][j][0]&=dp[(i-1)%2][j][0];
35            else
36                for(int j=0;j<maxnum;j++)
37                    dp[i%2][j][1]&=dp[(i-1)%2][j+1][0].set(i);
38        }
39        for(int i=0;i<=maxnum;i++)
40            res&=dp[n%2][i][0];
41
42        for(int i=0;i<maxnum;i++)
43            dp[0][i][0]=one,dp[0][i][1]=zero.set(0);
44        dp[0][maxnum][0]=dp[0][maxnum][1]=one;
45        for(int i=1;i<=n;i++)
46        {
47            for(int j=0;j<=maxnum;j++)
48                dp[i%2][j][0]=dp[i%2][j][1]=one;
49            for(int j=0;j<=maxnum;j++)
50                dp[i%2][j][0]&=dp[(i-1)%2][j][1];
51            for(int j=0;j<maxnum;j++)
52                dp[i%2][j][1]&=dp[(i-1)%2][j+1][1].set(i);
53            if(!data[i-1])
54                for(int j=0;j<=maxnum;j++)
55                    dp[i%2][j][0]&=dp[(i-1)%2][j][0];
56            else
57                for(int j=0;j<maxnum;j++)
58                    dp[i%2][j][1]&=dp[(i-1)%2][j+1][0].set(i);
59        }
60        for(int i=0;i<maxnum;i++)
61            res&=dp[n%2][i][1];
62
63
64        if(res.count()==0) printf("0 0\n");
65        else
66        {
67            int pos=-1;
68            for(int i=0;i<n&&pos==-1;i++)
69                if(res[i])
70                    pos=i;
71            printf("%d %d\n",res.count(),pos+1);
72        }
73    }
74    return 0;
75}

yzhw 2011-01-24 01:01 发表评论

pku1337 A Lazy Worker 很诡异的DP

yzhw — Sat, 22 Jan 2011 18:44:00 GMT

题意：
很多人这题题目读不懂，我详细解释下：一个懒工人，他想工作的时间尽量少。有N个任务，每个任务有开始时间和deadline，工人完成这个工作需要ti时间。如果某个时刻有工作可以做（这里是说，如果从这个时刻开始某个工作，在deadline之前能够完成)，那么这个工人必须做，但是如果这个时刻存在着多余1件工作可以做，工人可以选择；假设这个时刻没有工作可以做了，工人就可以偷懒直到有新的任务到来。

解法：
这题初看觉得很麻烦，但是题目中有句话太给力了！ You should note that for each job i, the length of Ii, di - ai, is greater than or equal to ti, but less than 2*ti
这句话把后效性全部消除了，即不可能出现这种情况，在t1这个决策点出现了第k个工作，在t1后的某个决策点t2又出现了第k个工作，明白了？
DP方程：
dp[t]=min(work[i]+dp[t+work[i]]) work指在第t个时间点能够可以开始做的工作
如果在第t个时刻没有任务可做，那么dp[t]=dp[t+1]

代码：

1 //============================================================================
2 // Name        : pku1337.cpp
3 // Author      : yzhw
4 // Version     :
5 // Copyright   : yzhw
6 // Description : Hello World in C++, Ansi-style
7 //============================================================================
8
9 #include <iostream>
10 #include <algorithm>
11 #include <vector>
12 #include <cstring>
13 using namespace std;
14 vector<int> work[251];
15 int data[101][3],n,minnum,maxnum,dp[300];
16 int getdp(int t)
17 {
18     if(t>maxnum) return 0;
19     else return dp[t];
20 }
21 int main() {
22     int test;
23     cin>>test;
24     while(test--)
25     {
26         cin>>n;
27         minnum=300;
28         maxnum=-1;
29         for(int i=0;i<=250;i++)
30             work[i].clear();
31         for(int i=0;i<n;i++)
32         {
33             cin>>data[i][0]>>data[i][1]>>data[i][2];
34             for(int j=data[i][1];j+data[i][0]<=data[i][2];j++)
35                 work[j].push_back(i);
36             minnum=min(minnum,data[i][1]);
37             maxnum=max(maxnum,data[i][2]-data[i][0]);
38         }
39         memset(dp,0,sizeof(dp));
40         for(int t=maxnum;t>=minnum;t--)
41           if(work[t].empty())
42               dp[t]=dp[t+1];
43           else
44           {
45               dp[t]=data[work[t][0]][0]+getdp(data[work[t][0]][0]+t);
46               for(int i=1;i<work[t].size();i++)
47                 dp[t]=min(dp[t],data[work[t][i]][0]+getdp(data[work[t][i]][0]+t));
48           }
49         cout<<dp[minnum]<<endl;
50     }
51     return 0;
52 }
53

yzhw 2011-01-23 02:44 发表评论

pku 1241 Knockout Tournament 树形DP，很好的题目

yzhw — Wed, 19 Jan 2011 17:44:00 GMT

题意：

看图说话，一棵锦标赛树（具体不描述，看DS书去），问每个队员的最好名次和最坏名次

分析：
求最好名次应该从上向下划分状态，而求最坏名次从下向上划分状态，举个例子吧，看第三排第一个1，它的最坏名次是第四排第一个1的最坏名次加上它的1^n-右孩子的最坏名次-1，而它的最好名次则是第二排第一个1的最好名次，它旁边那个3的最好名次就是3的父节点（1）的最好名次+1，大概明白什么意思了吧？看代码吧～。

代码：

1 # include <cstdio>
2 # include <cstring>
3 using namespace std;
4 # define max(a,b) ((a)>(b)?(a):(b))
5 # define min(a,b) ((a)<(b)?(a):(b))
6 int tree[1024],n;
7 int worst[1024],best[1024],high[1024],low[1024];
8 int main()
9 {
10     while(true)
11     {
12         scanf("%d",&n);
13         if(!n) break;
14         for(int i=1<<n;i<1<<(n+1);i++)
15             tree[i]=1+i-(1<<n),worst[i]=1<<n;
16         for(int t=n-1;t>=0;t--)
17             for(int i=1<<t;i<1<<(t+1);i++)
18             {
19                  scanf("%d",tree+i);
20                  worst[i]=(tree[i]==tree[i<<1]?worst[i<<1]-(1<<n)+worst[(i<<1)+1]:worst[(i<<1)+1]-(1<<n)+worst[i<<1])-1;
21             }
22         best[1]=1;
23         for(int i=2;i<1<<(n+1);i++)
24             best[i]=(tree[i]==tree[i>>1]?best[i>>1]:best[i>>1]+1);
25         for(int i=1;i<1<<(n+1);i++)
26             high[i]=low[i]=1<<n;
27         for(int i=1;i<1<<(n+1);i++)
28         {
29             high[tree[i]]=min(high[tree[i]],best[i]);
30             low[tree[i]]=min(low[tree[i]],worst[i]);
31         }
32         scanf("%d",&n);
33         while(n--)
34         {
35             int t;
36             scanf("%d",&t);
37             printf("Player %d can be ranked as high as %d or as low as %d.\n",t,high[t],low[t]);
38         }
39         printf("\n");
40     }
41     return 0;
42 }

yzhw 2011-01-20 01:44 发表评论

pku 1243 One Person 想法很牛的一道DP

yzhw — Wed, 19 Jan 2011 17:36:00 GMT

想了半天，没想出来，么办法，直接百度，先原样引用我参考的一篇文章

【题目大意】猜数字的游戏，可以猜N次，且只能猜大L次，求在一定的策略下，能猜到的最大的数。

----------------------------------------------------------
【分析】：很诡异的动态规划，看别人的分析：

1.先考虑L=0的情况，由于一次都不能猜错，因此只能从1开始，逐个向上猜，总数不能超过G；
2.若G<=L，等价于G=L的情况，因为此时允许猜的次数限制了最大的数，总数为2^G
3.一般的情况，比如L=1时，可以设想，只能猜错一次的话，这个数不能太大，否则猜错了一点作用也没有，因此要确保即使本次猜错也能在以后的G-1次猜中，这就转化成了(G-1,0)的情况，也就是说必胜的策略应当为先猜G，如果错，则从1~G-1逐次的猜，如果猜对了就转化成了(G-1,1)的情况，他应当再猜G+G-1……对于G=i,L=j的情况也是一样的考虑，可以列出状态转移方程：
opt[i][0]= i;
opt[i][i]= 2^i-1;
opt[i][j]= opt[i-1][j]+ opt[i-1][j-1]+ 1;

Source Code

Problem: 1243		User: Sasuke_SCUT
Memory: 380K		Time: 0MS
Language: G++		Result: Accepted

Source Code

#include
#include
#include
int main()
{
	int G,L,i,j,T,dp[31][31];
	T=1;
	while(scanf("%d %d",&G,&L) && G)
	{
		memset(dp,0,sizeof dp);
		dp[0][0]=1;
		for(i=1;i<=G;i++)
		{
			dp[i][0]=i;
			for(j=1;j<=L;j++)
				if(j>=i)
					dp[i][j]=pow(2.0,i)-1;
				else
					dp[i][j]=dp[i-1][j]+1+dp[i-1][j-1];
		}
		printf("Case %d: %d\n",T++,dp[G][L]);
	}
	return 0;
}

yzhw 2011-01-20 01:36 发表评论

pku1205 Water Treatment Plants 递推（说DP也可以把。。）

yzhw — Sat, 15 Jan 2011 09:22:00 GMT

题意：
一个污水处理系统吗，n个城市，每个城市可以选择
1、将左边城市过来的污水和右边城市过来的污水连同本身的污水排到河里
2、将左边来的污水连同自己的污水排到右边
3、将右边来的污水连同自己的污水排到左边

解法：
设状态dp[i][0]为第i个城市选择将污水传到左边的方案数，dp[i][1]为第i个城市选择将污水排入河道的方案数，dp[i][2]为选择将污水排到右边城市的方案数
然后有递推式
dp[i][2]=dp[i][1]=sum(dp[i-1][j]),j=0,1,2
dp[i][0]=dp[i-1][0]+dp[i-1][1]
这个应该不难理解吧？
如果最后一个城市选择后两种方案，那么前面城市怎么连都无所谓
而最后一个城市选择第一个方案，那么第n-1个城市不能选择将污水排到第n个城市
注意初始条件，dp[1][0]=0,dp[1][1]=dp[1][2]=1;
然后就是java BigInteger ，嘻嘻

1import java.io.*;
2import java.math.*;
3public class Main {
4
5    /**
6     * @param args
7     */
8    public static void main(String[] args) throws IOException{
9        StreamTokenizer in=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
10        BigInteger dp[][]=new BigInteger[101][3];
11        dp[1][0]=BigInteger.ZERO;
12        dp[1][1]=BigInteger.ONE;
13        dp[1][2]=BigInteger.ONE;
14        for(int i=2;i<=100;i++)
15        {
16            dp[i][1]=dp[i-1][0].add(dp[i-1][1].add(dp[i-1][2]));
17            dp[i][0]=dp[i-1][0].add(dp[i-1][1]);
18            dp[i][2]=dp[i-1][0].add(dp[i-1][1].add(dp[i-1][2]));
19        }
20        while(in.nextToken()!=in.TT_EOF)
21            System.out.println(dp[(int)in.nval][0].add(dp[(int)in.nval][1]));
22    }
23
24
25
26}
27

yzhw 2011-01-15 17:22 发表评论

pku 1625 Censored! 自动机经典题，手写高精度WA了5次。。。。。

yzhw — Thu, 13 Jan 2011 01:57:00 GMT

题意：
问不包含n个子串的长度为m的字符串的构造个数。

解法：
构造trie图，然后DP求长度为m的合法串个数
以前高精度都靠java，这次手写，各种错误。。。唉。。

代码：

  1 # include <iostream>
  2 # include <cstring>
  3 using namespace std;
  4 struct BigInteger
  5 {
  6     int bit[100];
  7     bool init;
  8     BigInteger()
  9     {
10         memset(bit,0,sizeof(bit));
11         init=true;
12     }
13     BigInteger operator+(const BigInteger &pos)
14     {
15         BigInteger res;
16         res.init=init;
17         for(int i=0;i<99;i++)
18         {
19             res.bit[i]+=bit[i]+pos.bit[i];
20             res.bit[i+1]+=res.bit[i]/10;
21             res.bit[i]%=10;
22         }
23         return res;
24     }
25     void print()
26     {
27         int i;
28         for(i=99;i>0&&!bit[i];i--);
29         for(int j=i;j>=0;j--)
30             cout<<bit[j];
31         cout<<endl;
32     }
33 };
34 struct node
35 {
36     node *nxt[51],*pre;
37     bool end;
38     void clear()
39     {
40         memset(nxt,NULL,sizeof(nxt));
41         end=false;
42         pre=NULL;
43     }
44     node()
45     {
46         clear();
47     }
48 }buffer[200];
49 int map[255];
50 int c=1,n,m,num;
51 void insert(char *str)
52 {
53     node *p=buffer;
54     for(int i=0;str[i]!='\0';i++)
55     {
56         if(!(p->nxt[map[str[i]]]))
57                 p->nxt[map[str[i]]]=&buffer[c++];
58         p=p->nxt[map[str[i]]];
59     }
60     p->end=true;
61 }
62 void make_per()
63 {
64     int s=-1,e=-1;
65     node *q[200];
66     node *p=buffer;
67     for(int i=0;i<n;i++)
68         if(p->nxt[i])
69         {
70             p->nxt[i]->pre=p;
71             q[++e]=p->nxt[i];
72         }
73         else
74             p->nxt[i]=p;
75     while(s!=e)
76     {
77         p=q[++s];
78         for(int i=0;i<n;i++)
79         {
80             node *pre=p->pre;
81             while(pre->nxt[i]==NULL) pre=pre->pre;
82             if(p->nxt[i])
83             {
84                 p->nxt[i]->pre=pre->nxt[i];
85                 p->nxt[i]->end=(p->nxt[i]->pre->end||p->nxt[i]->end);
86                 q[++e]=p->nxt[i];
87             }
88             else
89                 p->nxt[i]=pre->nxt[i];
90         }
91     }
92 }
93 BigInteger dp[200][55],zero,one;
94 BigInteger solve(int s,node *p)
95 {
96     if(p->end) return zero;
97     else if(s==m) return one;
98     else if(!(dp[p-buffer][s].init)) return dp[p-buffer][s];
99     else
100     {
101         dp[p-buffer][s].init=false;
102         for(int i=0;i<n;i++)
103         {
104             dp[p-buffer][s]=dp[p-buffer][s]+solve(s+1,p->nxt[i]);
105         }
106         return dp[p-buffer][s];
107     }
108
109 }
110 int main()
111 {
112     cin>>n>>m>>num;
113     char str[128];
114     cin>>str;
115     int tc=0;
116     for(int i=0;str[i]!='\0';i++)
117         map[str[i]]=tc++;
118     while(num--)
119     {
120         cin>>str;
121         insert(str);
122     }
123     make_per();
124     one.bit[0]=1;;
125     solve(0,buffer);
126     dp[0][0].print();
127     return 0;
128
129 }

yzhw 2011-01-13 09:57 发表评论

pku3691 DNA repair 自动机+DP

yzhw — Wed, 12 Jan 2011 05:21:00 GMT

摘要: 题意：给出一个DNA序列，和若干病毒DNA片段，问最少修改DNA的次数使得DNA序列中不包含病毒解法：首先构造DFA（再次犯了和福州现场赛一样的错误，没有+结束标记状态的转移。。。。WA了N久），然后就是在状态机上的DP了令dp[i]][j]为当前在自动机第i个节点上时suffix(j)成为合法子串需要修改的最少次数。下面状态转移就简单了。。（这种状态转移通过方程和难描述，大家看程序吧，我写的很清... 阅读全文

yzhw 2011-01-12 13:21 发表评论

pku 1180 Batch Scheduling 经典斜率优化

yzhw — Mon, 03 Jan 2011 13:52:00 GMT

题意:
N个任务，每个任务有两个参数，完成需要的时间t以及因子f，现在将这些任务分组，加工每个分组前机器需要冷却时间start，完成一组任务耗时为 t + Start + (T_x + T_x+1 + ... + T_x+k)，问最少耗费的时间。
解法：
首先先解决这个问题，在这种分组数不确定的问题中，根据背包九讲中无限背包的策略，外层循环只要一层即可完成。
关键是内重循环还要枚举本组的起始位置，如果暴力的做就要N2了。
下面试图对初始的DP方程进行优化
考虑两种规划方向，第一种规划方向是从前到后
dp[i]=min{dp[k]+(dp[k]+sumt(i)-sumt(k)+start)*(sumf(i)-sumf(k))} 无比复杂的一个式子，推了N小时，在这个式子上下手似乎非常困难。。。（3个决策变量）
但是，如果换种思路，从后向前，将sumt以及sumf重新定义为最后一个任务到第i个任务的时间和和参数和，这样就简单多了。
dp[i]=min{dp[k]+(sumt(i)-sumt(k)+start)*sumf(i)}
然后很轻易能发现这个满足斜率优化的条件（2个待定决策变量，sumt(k)和dp(k)）。
关于斜率优化，一般有代数和几何两种方法。先说几何方法
令g=dp[k]+(sumt(i)-sumt(k)+start)*sumf(i)}，y=dp[k],x=sumt[k]
现在要使g最小
将式子整理下
y=sumf(i)*x+f-(start+sumt(i))*sumf(i)
将这个看做一个线性函数，目标要使得截距最小
再观察一下，斜率sumf(i)恒为正，且是随着i单调递减的，换句话说，是随着规划的过程单调递增的，而自变量x也是随着规划的过程单调递增的。我们画个图比划下

首先，我们要维护的是一个上凹线，因为凹线内部的点不会被斜率为正的直线切到。再者，我们发现最优决策就在凹线的左端。我们来观察蓝色的线，假设这个是第i阶段的决策线，灰色凹线与蓝色线切点左侧的绿色部分显然是可以丢弃的。应为在切点处截距达到最小。并且在以后的决策中（浅蓝色的线），该段同样不会有任何作用。根据以上观察，我们可以使用栈队列（很多人简称为单调队列）的数据结构。这个东西网上介绍的比较多，我就不细说了。
第二种方法就是代数法。
我看网上有一个牛写的不错，就贴过来吧- -

引自http://hi.baidu.com/wangkun_zhen/blog/item/5e85d0cc4fb887590fb345dd.html     dp[i] = min{dp[j] + (S + sumT[i] - sumT[j]) * sumF[i]        { i < j <= n + 1 }
                                                                      边界条件 dp[n+1] = 0
                                                                                     sumT[n+1]=sumF[n+1]=0

         可以清楚的看到，此种DP方法的时间复杂度是O(n^2)的，那么如何降低复杂度呢？

经典的优化分析：
         我们考虑在计算dp[i]时，对于i < j < k来说，如果保证决策k比决策j大的条件是：

dp[j] + (S + sumT[i] - sumT[j]) * sumF[i] < dp[k] + (S + sumT[i] - sumT[k]) * sumF[i]

通过移项整理，可以化简为：

                        (dp[j] - dp[k]) / (sumT[j] - sumT[k]) < sumF[i]

这个类似于斜率的东西又怎么来优化？
为了证明和更好的说明接下来的优化，我们定义这么几个变量：
设：
                  d[i, x] = dp[x] + (S + sumT[i] - sumT[x]) * sumF[i] ;
                  g[j, k] = (dp[j] - dp[k]) / (sumT[j] - sumT[k])

那么我们可以总结一下上面推出来的式子：
根据上面有：
                               i同理可证：             d[i, j] < d[i, k]    <=>   g[j, k] < sumF[i]         决策j比决策k小

进而我们发现这么一个问题，当i < j < k < l时，如果有g[j, k] < g[k, l]，那么k永远都不会成为计算dp[i]时的决策点。

证明：
如果g[j, k] < g[k, l]，那么我们可以分两个方面考虑g[j, k]与sumF[i]的关系：
(1)如果g[k, l] >= sumF[i]，那么决策k大于等于决策l，也就说决策k不可能是决策点
(2)如果g[j, k] < sumF[i],那么决策k要大于决策j，所以k也不可能是决策点

根据上面的结论和一些特性，我们可以考虑维护一个斜率的双向队列来优化整个DP过程：

(1)假设i(马上要入队的元素) 依次是队列尾部的元素，那么我们就要考虑g[i, j]是否大于g[j, k]，如果g[i, j] < g[j, k]，那么可以肯定j一定不会是决策点，所以我们可以从队列中将j去掉，然后依次向前推，直到找到一个队列元素少于3个或者g[i j] >= g[j, k]的点才停止。
(2)假设a>b(a是头元素)是依次是队列头部的元素，那么我们知道，如果g[b, a] < sumF[i]的话，那么对于i来说决策点b肯定优于决策点a，又由于sumF[i]是随着i减少而递增的（这个就是为什么倒推的原因），所以当g[a, b] < sumF[i]时，就一定有g[a, b] < sumF[i-1]，因此当前的决策点a不仅仅在考虑dp[i]时不会是最佳决策点，而且在后面的DP中也一定不会是最佳决策点，所以我们可以把a从队列的头部删除，依次往后如此操作，直到队列元素小于2或者g[b, a] >= sumF[i]。
(3)对于i的更新，一定是队列头部的决策点最好，所以O(1)即可转移。

初始化的时候要注意，必须在n+1的位置处加一个虚拟的状态，不能将第一个状态（即i=n的状态）作为初始状态，因为可能将所有任务仅分为一段。
代码：

1# include <stdio.h>
2# define N 10005
3int n,start,st[N],sf[N];
4int q[N],s=-1,e=0;
5int dp[N];
6int cmp(const int a,const int b,const int k)
7{
8    if(dp[b]-dp[a]<(long long)k*(st[b]-st[a])) return -1;
9    else if((long long)dp[b]-dp[a]==(long long)k*(st[b]-st[a])) return 0;
10    else return 1;
11}
12int cmp1(const int y1,const int x1,const int y2,const int x2,const int y3,const int x3)
13{
14    if(((long long)y3-y2)*(x2-x1)<((long long)y2-y1)*(x3-x2)) return -1;
15    else if(((long long)y3-y2)*(x2-x1)==((long long)y2-y1)*(x3-x2)) return 0;
16    else return 1;
17}
18int main()
19{
20    int i;
21    scanf("%d%d",&n,&start);
22    for(i=0;i<n;i++)
23        scanf("%d%d",st+i,sf+i);
24    for(i=n-2;i>=0;i--)
25    {
26        st[i]+=st[i+1];
27        sf[i]+=sf[i+1];
28    }
29    q[e]=n;
30    dp[n]=0;
31    for(i=n-1;i>=0;i--)
32    {
33       while(e>=s+2&&cmp(q[s+1],q[s+2],sf[i])!=1) s++;
34       dp[i]=dp[q[s+1]]+(start+st[i]-st[q[s+1]])*sf[i];
35       while(e>=s+2&&cmp1(dp[q[e-1]],st[q[e-1]],dp[q[e]],st[q[e]],dp[i],st[i])!=1) e--;
36       q[++e]=i;
37    }
38    printf("%d\n",dp[0]);
39    return 0;
40}
41

yzhw 2011-01-03 21:52 发表评论

pku 1173 Bar Codes 经典DP，逐位确定rank

yzhw — Sun, 02 Jan 2011 15:17:00 GMT

题意：
给出条形码系统
BC(n,k,m) is the set of all symbols with k bars that together extend over exactly n units, each bar being at most m units wide.
1、给出n,k,m，条形码第一条是黑色。问有多少种不同的划分方式。
2、给出条形码，求它的rank（字典序）

第一问应该很好解决，BC(n,k,m)=sum(BC(n-i,k-1,m)),i=1,2..m
第二问也是用经典的逐位确定的方法，唯一要注意的是，白条要从大到小累加（因为0代表白色，显然，当前条0的位数越多，字典序越小），而黑条要从小到大累加

代码：

1# include <cstdio>
2# include <cstring>
3# include <algorithm>
4using namespace std;
5int c[35][35],n,k,m;
6int main()
7{
8    scanf("%d%d%d",&n,&k,&m);
9    memset(c,0,sizeof(c));
10    for(int num=1;num<=min(n,m);num++)
11       c[num][1]=1;
12    for(int num=2;num<=n;num++)
13      for(int i=2;i<=k;i++)
14        for(int j=max(1,num-m);j<num;j++)
15           c[num][i]+=c[j][i-1];
16    printf("%d\n",c[n][k]);
17    int num;
18    scanf("%d",&num);
19    while(num--)
20    {
21        char str[50];
22        char color='1';
23        int last=0,rank=0,co=1;
24        scanf("%s",str);
25        for(int i=0;i<strlen(str);i++)
26        {
27            if(str[i]!=color)
28            {
29               int len=i-last;
30               switch(color)
31               {
32                  case '1':
33                       for(int j=last+1;j<i;j++)
34                          rank+=c[n-j][k-co];
35                       color='0';
36                       break;
37                  case '0':
38                       for(int j=min(n-1,last+m);j>i;j--)
39                          rank+=c[n-j][k-co];
40                       color='1';
41                       break;
42               };
43               co++;
44               last=i;
45            }
46        }
47        printf("%d\n",rank);
48    }
49      return 0;
50}
51

yzhw 2011-01-02 23:17 发表评论

pku 3373 Changing Digits 贪心的DP，注意DP方向

yzhw — Sat, 01 Jan 2011 10:39:00 GMT

题意：
给出2个整数N和K，求满足以下条件的整数M
1、M与N位数相同
2、M能被K整除
满足以上两点的情况下，与N不同位数的个数以及M值最小的优先
n<10^100
k<10000
解法：
考虑到k不大，状态可以设置为dp[i][k]，即i位的数字中余数为k的需要修改的最小值
但是由于最后一个约束条件，即数小的优先，如果从正向DP，不能满足要求
应为从状态i-1转移到状态i的过程中，贪心的DP保证了第i位取值最小。可能出现这种状况：
假设abcd%k==efgh%k
de。这样就不满足题意了。
解决方法是逆向DP，这样既能保证靠近前面的位取值最小。

代码：

1Source Code
2
3Problem: 3373  User: yzhw
4Memory: 12180K  Time: 1235MS
5Language: G++  Result: Accepted
6
7Source Code
8# include <cstdio>
9# include <cstring>
10using namespace std;
11int dp[105][10000];
12int path[105][10000][2];
13void print(int start,int left,int len)
14{
15   if(start>=len+1) return;
16   printf("%d",path[start][left][1]);
17   print(start+1,path[start][left][0],len);
18}
19int main()
20{
21    char str[105];
22    int mod[105];
23    while(scanf("%s",str+1)!=EOF)
24    {
25        int k;
26        scanf("%d",&k);
27        memset(dp,-1,sizeof(dp));
28        mod[strlen(str+1)]=1%k;
29        for(int i=strlen(str+1)-1;i>=1;i--)
30           mod[i]=(mod[i+1]*10)%k;
31        dp[strlen(str+1)+1][0]=0;
32        for(int i=strlen(str+1);i>0;i--)
33          for(int p=(i==1?1:0);p<10;p++)
34            for(int j=0;j<k;j++)
35             if(dp[i+1][j]!=-1)
36                    if(dp[i][(j+p*mod[i])%k]==-1||dp[i][(j+p*mod[i])%k]>dp[i+1][j]+(p!=str[i]-48))
37                    {
38                       dp[i][(j+p*mod[i])%k]=dp[i+1][j]+(p!=str[i]-48);
39                       path[i][(j+p*mod[i])%k][0]=j;
40                       path[i][(j+p*mod[i])%k][1]=p;
41                    }
42        print(1,0,strlen(str+1));
43        printf("\n");
44    }
45    return 0;
46}
47
48
49

yzhw 2011-01-01 18:39 发表评论

pku 1203 Timetable 拆点+DP最短路

yzhw — Thu, 09 Dec 2010 13:25:00 GMT

摘要: 题意：TimetableTime Limit: 3000MS Memory Limit: 65536K Total Submissions: 281 Accepted: 86 Description You are the owner of a railway system between n cities, numbered by integers from 1 t... 阅读全文

yzhw 2010-12-09 21:25 发表评论

fzu 2006 Farm Game(The 35th ACM/ICPC Asia Regional Fuzhou Site) DAG上的DP

yzhw — Tue, 07 Dec 2010 05:08:00 GMT

题意：
给出一个DAG，每个点上有一定的价值p和数量w,给出一些转换关系：a_i-1 a_i b_i ，即a_i-1可以兑换成b_i单位a_i ,然后问这些点的最大价值。
解法：
由于是DAG，可以用DP来解，dp[pos]=max{p[pos],dp[k]*rate[pos][k]},g[pos][k]=true
然后结果就是sum{dp[i]*w[i]}
这次第一次参加regional，fzu现场赛时候各种手残脑残，N个能够秒的题都没去看。甚可惜。。。回来看了下题目都不是多困难的，做个5题没问题的说。。。哎，明年再一雪耻辱吧。。
代码：

1# include <cstdio>
2# include <vector>
3using namespace std;
4const int N=10005;
5struct node
6{
7  int nxt;
8  double rate;
9  node(int n,double r):nxt(n),rate(r){};
10};
11vector<node> g[N];
12double p[N],w[N];
13bool used[N];
14int n;
15void solve(int pos)
16{
17   if(used[pos]) return;
18   used[pos]=true;
19   for(int i=0;i<g[pos].size();i++)
20   {
21     solve(g[pos][i].nxt);
22     if(g[pos][i].rate*p[g[pos][i].nxt]>p[pos]) p[pos]=g[pos][i].rate*p[g[pos][i].nxt];
23   }
24}
25int main()
26{
27    while(true)
28    {
29      scanf("%d",&n);
30      if(!n) break;
31      for(int i=1;i<=n;i++)
32      {
33        scanf("%lf%lf",p+i,w+i);
34        g[i].clear();
35        used[i]=false;
36      }
37      int m;
38      scanf("%d",&m);
39      while(m--)
40      {
41        int k;
42        scanf("%d",&k);
43        int last,now;
44        scanf("%d",&last);
45        k--;
46        while(k--)
47        {
48           double r;
49           scanf("%lf%d",&r,&now);
50           g[last].push_back(node(now,r));
51           last=now;
52        }
53      }
54      for(int i=1;i<=n;i++)
55          solve(i);
56      double ans=0;
57      for(int i=1;i<=n;i++)
58        ans+=p[i]*w[i];
59      printf("%.2f\n",ans);
60    }
61    return 0;
62}
63

yzhw 2010-12-07 13:08 发表评论

pku3670 Eating Together DP+堆

yzhw — Sun, 05 Dec 2010 17:54:00 GMT

题意：
给出一个序列（只包含1、2、3），问需要修改最少元素的个数使得这个序列递增或递减。
解法：
discuss里有说这题是LIS，没有仔细想，我是自己推DP来做的。。
设sum1[i]为将数列前i个全部修正为1需要修改的次数，sum2、sum3亦同。
先写修改最少元素使得序列递增的做法
dp[j][i]=min(dp[j-1][i],sum[j][i]-sum[j][k]+dp[j-1][k],sum[j][i]);
观察第二项
sum[j][i]-sum[j][k]+dp[j-1][k]，前一项是与k无关的常量，所以可以用一个堆来记录前i-1项dp[j-1][k]-sum[j][k]的最小值，这样可以省去一重枚举k的复杂度
序列递减做法亦同。
总复杂度O(nlog_n)

再次犯N个NC错误：
1、最佳值应该为dp[n],而不是dp[1..n]中的最小值。。。
2、开始写DP方程的时候min里面漏了一项。。不过这个似乎不能怪我，题目理解有点歧义，我原来以为必须要用到1、2、3这3个元素。。所以dp方程里只有一项。。然后看discuss发现我理解错了，修正了下dp方程，结果。。汗。。

代码：

1# include <iostream>
2using namespace std;
3# include <queue>
4# include <vector>
5# include <cstring>
6# include <cstdlib>
7# define min(a,b) ((a)<(b)?(a):(b))
8const int N=30005;
9int s[3][N],*sum,n,dp[N],tdp[N];
10struct cmp
11{
12   bool operator()(const int &a,const int &b) const
13   {
14      return dp[a]-(a-sum[a])>dp[b]-(b-sum[b]);
15   }
16};
17priority_queue<int,vector<int>,cmp> q;
18void print()
19{
20   for(int i=1;i<=n;i++)
21     cout<<dp[i]<<" ";
22   cout<<endl;
23  // system("pause");
24}
25int main()
26{
27    memset(s,0,sizeof(s));
28    cin>>n;
29    for(int i=1;i<=n;i++)
30    {
31        for(int j=0;j<3;j++)
32          s[j][i]=s[j][i-1];
33        int t;
34        cin>>t;
35        s[t-1][i]++;
36    }
37    int ans=0xfffffff;
38    for(int i=1;i<=n;i++)
39       dp[i]=i-s[0][i];
40  //  print();
41    for(int i=2;i<=3;i++)
42    {
43       while(!q.empty()) q.pop();
44      // memset(tdp,0,sizeof(tdp));
45       sum=s[i-1];
46       q.push(1);
47       tdp[1]=min(dp[1],1-sum[1]);
48       for(int j=2;j<=n;j++)
49       {
50          tdp[j]=min(dp[q.top()]-(q.top()-sum[q.top()])+j-sum[j],dp[j]);
51          q.push(j);
52       }
53       for(int j=1;j<=n;j++)
54         tdp[j]=min(tdp[j],j-sum[j]);
55       memcpy(dp,tdp,sizeof(dp));
56   //    print();
57    }
58
59       ans=min(ans,dp[n]);
60    for(int i=1;i<=n;i++)
61       dp[i]=i-s[2][i];
62   // print();
63    for(int i=2;i<=3;i++)
64    {
65       while(!q.empty()) q.pop();
66      // memset(tdp,0,sizeof(tdp));
67       sum=s[3-i];
68       q.push(1);
69       tdp[1]=min(dp[1],1-sum[1]);
70       for(int j=2;j<=n;j++)
71       {
72          tdp[j]=min(dp[j],dp[q.top()]-(q.top()-sum[q.top()])+j-sum[j]);
73          q.push(j);
74       }
75       for(int j=1;j<=n;j++)
76         tdp[j]=min(tdp[j],j-sum[j]);
77       memcpy(dp,tdp,sizeof(dp));
78    //   print();
79    }
80       ans=min(ans,dp[n]);
81    cout<<ans<<endl;
82  // system("pause");
83    return 0;
84}
85

yzhw 2010-12-06 01:54 发表评论

pku 2411 Mondriaan's Dream 状态压缩DP

yzhw — Thu, 25 Nov 2010 11:18:00 GMT

简要题意：
给出一个n*m的矩形，要求用1*2的矩形拼出来（可以旋转），问总共有多少种拼法。

题解：
将第i行进行状态压缩表示
(0,0,0,0..0) 0代表向下没有插头，1代表向下有插头
然后向下一行转移方法就是
如果当前列有插头，则取消掉插头；
如果当前列没有插头：
1、如果下一列也没有插头，可以水平放一个小矩形或者竖直放两个小矩形，插头状态不变
2、如果下一列有插头，则竖直放一个小矩形，添加两个向下的插头
注意要用long long
代码：

1 # include <iostream>
2 # include <cstring>
3 # define getbit(c,pos) (((c)&(1<<(pos)))>0)
4 using namespace std;
5 void add(int code,int now,int m,long long dp[],int num)
6 {
7    if(now==m)
8       dp[code]+=num;
9    else
10    {
11        switch(getbit(code,now))
12        {
13           case 1:
14                add(code-(1<<now),now+1,m,dp,num);
15                break;
16           case 0:
17                if(now!=m-1&&!getbit(code,now+1))
18                      add(code,now+2,m,dp,num);
19                add(code+(1<<now),now+1,m,dp,num);
20                break;
21        };
22    }
23 }
24 int main()
25 {
26     int n,m;
27     while(true)
28     {
29        cin>>n>>m;
30        if(!n&&!m) break;
31        long long dp[15][2048];
32        memset(dp,0,sizeof(dp));
33        dp[0][0]=1;
34        for(int i=0;i<n;i++)
35           for(int j=0;j<(1<<m);j++)
36             if(dp[i][j])
37                  add(j,0,m,dp[i+1],dp[i][j]);
38        cout<<dp[n][0]<<endl;
39     }
40     return 0;
41 }
42

yzhw 2010-11-25 19:18 发表评论

pku 1935 Journey 树形DP

yzhw — Mon, 15 Nov 2010 18:06:00 GMT

简明题意：给出一个城市的道路网(是一棵树)，每条路有一定的权值，一个人在第k点，给出一些城市列表，问这个人游览完这些城市最小花费为多少
解法：一条最优的路线肯定是这样

有且仅有一条路线是单向的。
下面定义状态:
dp[i][0]为游览完以i为根节点的子树（仅仅游览需要游览的城市，如果没有即为0）且最后回到i节点需要的最短长度
dp[i][1]为不需要回到i节点的最短长度
dp[i][0]=sum(dp[j][0]+val[i][j](如果dp[j][0]不为0或者j为需要访问的城市)),j为i的孩子节点
dp[i][1]=dp[i][0]-max(dp[j][0]-dp[j][1]+val[i][j](如果dp[j][0]不为0或者j为需要访问的城市))
最后结果就是dp[start][1]
程序如下

1# include <cstdio>
2# include <cstring>
3# include <vector>
4//# include
5using namespace std;
6# define max(a,b) ((a)>(b)?(a):(b))
7int dp[50001][2];
8bool need[50001];
9int g[50001],nxt[100005],val[100005],v[100005],c=0;
10inline void insert(int a,int b,int p)
11{
12   v[c]=b;
13   val[c]=p;
14   nxt[c]=g[a];
15   g[a]=c++;
16}
17void solve(int pos,int pre)
18{
19     int maxnum=0;
20     dp[pos][0]=dp[pos][1]=0;
21     for(int p=g[pos];p!=-1;p=nxt[p])
22       if(v[p]!=pre)
23       {
24          solve(v[p],pos);
25          maxnum=max(dp[v[p]][0]-dp[v[p]][1]+(dp[v[p]][0]||need[v[p]]?val[p]:0),maxnum);
26          dp[pos][0]+=dp[v[p]][0]+(dp[v[p]][0]||need[v[p]]?2*val[p]:0);
27       }
28     dp[pos][1]=dp[pos][0]-maxnum;
29}
30int main()
31{
32    int n,start,num;
33    scanf("%d%d",&n,&start);
34    memset(g,-1,sizeof(g));
35    memset(need,false,sizeof(need));
36    memset(dp,-1,sizeof(dp));
37    for(int i=1;i<n;i++)
38    {
39       int a,b,p;
40       scanf("%d%d%d",&a,&b,&p);
41       insert(a,b,p);
42       insert(b,a,p);
43    }
44    scanf("%d",&num);
45    while(num--)
46    {
47      int t;
48      scanf("%d",&t);
49      need[t]=true;
50    }
51    solve(start,-1);
52    printf("%d\n",dp[start][1]);
53   // system("pause");
54    return 0;
55}
56
57

yzhw 2010-11-16 02:06 发表评论

pku 2228 Naptime 简单DP，写的很挫，卡常数卡过去了。。。

yzhw — Sat, 06 Nov 2010 18:48:00 GMT

题意大概描述一下
有一只牛，在全天N小时内花B小时睡觉，然后每一个时间点都有一个休息值，假设选择在区间[s,e]内休息，则第s个时间点不能够获得休息值。现在请安排这只牛的作息时间，使得他的休息值最大。
状态dp[i][k][2]，i表示前i个小时，k表示休息了k个小时，最后一个状态表示最后一个小时是否在休息。然后由于可以形成环（即第N个小时在休息，则第1个小时能够获得能量），需要2个DP。状态转移应该很简单吧~具体看程序。话说这题谁有nlogn的方法?感觉n²好悬，常数还不小。。本机上跑了近1秒，用位运算、滚动数组等还有800ms，提交上去只有200ms。。看来poj的服务器很NB
贴代码

1 # include <cstdio>
2 # include <cstring>
3 using namespace std;
4 # define max(a,b) ((a)>(b)?(a):(b))
5 int data[3850];
6  int dp[2][2][3850],dp1[2][2][3850];
7 int main()
8 {
9    // freopen("input.txt","r",stdin);
10   //  freopen("output.txt","w",stdout);
11     int n,k;
12     scanf("%d%d",&n,&k);
13     for(int i=0;i<n;i++)
14         scanf("%d",data+i);
15     memset(dp,-1,sizeof(dp));
16     memset(dp1,-1,sizeof(dp1));
17     dp[0][0][0]=0;
18     dp[0][1][1]=0;
19     dp1[0][0][0]=0;
20     dp1[0][1][1]=data[0];
21     int res=0;
22     for(int i=1;i<n;i++)
23     {
24         memset(dp[i%2],-1,sizeof(dp[i%2]));
25         memset(dp1[i%2],-1,sizeof(dp1[i%2]));
26         dp[i%2][0][0]=0;
27         for(int j=1;j<=k;j++)
28         {
29             if(dp[(i-1)%2][0][j]!=-1)
30                 dp[i%2][0][j]=max(dp[i%2][0][j],dp[(i-1)%2][0][j]);
31             if(dp[(i-1)%2][1][j]!=-1)
32                 dp[i%2][0][j]=max(dp[i%2][0][j],dp[(i-1)%2][1][j]);
33             if(dp[(i-1)%2][0][j-1]!=-1)
34                 dp[i%2][1][j]=max(dp[i%2][1][j],dp[(i-1)%2][0][j-1]);
35             if(dp[(i-1)%2][1][j-1]!=-1)
36                 dp[i%2][1][j]=max(dp[i%2][1][j],dp[(i-1)%2][1][j-1]+data[i]);
37             if(dp1[(i-1)%2][0][j]!=-1)
38                 dp1[i%2][0][j]=max(dp1[i%2][0][j],dp1[(i-1)%2][0][j]);
39             if(dp1[(i-1)%2][1][j]!=-1)
40                 dp1[i%2][0][j]=max(dp1[i%2][0][j],dp1[(i-1)%2][1][j]);
41             if(dp1[(i-1)%2][0][j-1]!=-1)
42                 dp1[i%2][1][j]=max(dp1[i%2][1][j],dp1[(i-1)%2][0][j-1]);
43             if(dp1[(i-1)%2][1][j-1]!=-1)
44                 dp1[i%2][1][j]=max(dp1[i%2][1][j],dp1[(i-1)%2][1][j-1]+data[i]);
45         }
46     }
47     res=max(max(res,dp1[(n-1)%2][1][k]),max(dp[(n-1)%2][1][k],dp[(n-1)%2][0][k]));
48     printf("%d\n",res);
49     return 0;
50 }
51

yzhw 2010-11-07 02:48 发表评论

pku 2018 Best Cow Fences 斜率优化，注意中间运算结果超int

yzhw — Sat, 06 Nov 2010 17:53:00 GMT

具体分析间NOI论文：
浅谈数形结合思想在信息学竞赛中的应用，例题2
直接贴代码了。。
再次注意消除浮点误差时中间运算结果超出int范围！！

1 # include <stdio.h>
2 # define N 100005
3 # define less(x1,y1,x2,y2,x3,y3,x4,y4) (y2-y1)*(x4-x3)<=(y4-y3)*(x2-x1)
4 # define max(a,b) ((a)>(b)?(a):(b))
5 int data[N],q[N][2],s=-1,e=-1;
6 int n,f;
7 int main()
8 {
9     int i;
10     scanf("%d%d",&n,&f);
11     data[0]=0;
12     for(i=1;i<=n;i++)
13     {
14         scanf("%d",data+i);
15         data[i]+=data[i-1];
16     }
17     e++;
18     q[e][0]=0;
19     q[e][1]=0;
20     double res;
21     int y=-1,x=-1;
22     for(i=1;i<=n;i++)
23     {
24         while(s+2<=e&&i-q[s+2][0]>=f) s++;
25         while(e>=s+2&&less(q[e][0],q[e][1],i,data[i],q[e-1][0],q[e-1][1],q[e][0],q[e][1])) e--;
26         e++;
27         q[e][0]=i;
28         q[e][1]=data[i];
29         if(s<e&&i-q[s+1][0]>=f)
30             if(y==-1&&x==-1||x!=-1&&y!=-1&&((long long)data[i]-q[s+1][1])*x>(long long)y*(i-q[s+1][0]))
31                 y=data[i]-q[s+1][1],x=i-q[s+1][0];
32     }
33     printf("%d\n",(long long)(y*1000)/x);
34     return 0;
35 }

yzhw 2010-11-07 01:53 发表评论

pku1278 BOAT dp+rmq

yzhw — Sat, 06 Nov 2010 07:51:00 GMT

题目描述的好含糊
是这样的
有n个客户要租船，租期为t_i天。每个用户给供应商若干个选择列表：d_i,p_i,即商户在d日期前提供服务的话（这里指提供完服务，即在d_i-t_i天前即将船租给用户）就可以支付p单位的钱。
租赁必须采取先到先服务的策略（可以选择不租给某个用户），即时间的分配是从前到后按顺序的（这个是划分状态的基础）。
好了。说说做法
设状态dp[i][j]为已经考虑完第i个用户且第i个用户在第j时间还船产生的最大效益。
dp方程就很明了了dp[i][j]=max{dp[i-1][j-t_i]+val[i]}复杂度为O(n₂*计算val的复杂度)
val_i理解为在第i个用户的可选列表中d_i>=j中支付价格的最大值。这里如果朴素的实现的话就是O(n)复杂度，整个算法就是O(n³)，对于n=100这种数据应该没问题了。不过可以用rmq优化到O(logn)。具体实现方法见程序

  1 import java.util.*;
  2 class rmq
  3 {
  4     int data[];
  5     int arr[][];
  6     public rmq(ArrayList<choose> data)
  7     {
  8         this.data=new int[data.size()];
  9         for(int i=0;i<data.size();i++)
10             this.data[i]=data.get(i).mount;
11         arr=new int[data.size()][20];
12         init();
13     }
14     private void init()
15     {
16         for(int i=0;i<data.length;i++)
17             arr[i][0]=data[i];
18         for(int len=1;len<=data.length;len<<=1)
19             for(int i=0;i+(1<<len)<=data.length;i++)
20                 arr[i][len]=Math.max(arr[i][len-1], arr[i+(1<<(len-1))][len-1]);
21     }
22     public int query(int s)
23     {
24         int e=data.length-1;
25         int len=(int)(Math.log(e-s+1)/Math.log(2)+1e-6);
26         return Math.max(arr[s][len],arr[e-(1<<len)+1][len]);
27     }
28
29 }
30 class choose implements Comparable<choose>
31 {
32     int dead,mount;
33     public choose(int d,int m)
34     {
35         dead=d;
36         mount=m;
37     }
38     public int compareTo(choose pos)
39     {
40         return dead-pos.dead;
41     }
42
43 }
44 public class Main {
45
46     /**
47      * @param args
48      */
49     static int find(ArrayList<choose> data,int pos)
50     {
51         int s=0,e=data.size()-1;
52         while(s<=e)
53         {
54             int mid=(s+e)>>1;
55             if(data.get(mid).dead>=pos)
56                 e=mid-1;
57             else
58                 s=mid+1;
59         }
60         return e+1;
61     }
62     public static void main(String[] args) {
63         Scanner in=new Scanner(System.in);
64         while(in.hasNext())
65         {
66             int num=in.nextInt();
67             ArrayList<choose> list[]=new ArrayList[num+1];
68             for(int i=0;i<list.length;i++)
69                 list[i]=new ArrayList<choose>();
70             int time[]=new int[num+1];
71             for(int i=1;i<=num;i++)
72                 time[i]=in.nextInt();
73             num=in.nextInt();
74             while((num--)!=0)
75             {
76                 int id=in.nextInt();
77                 list[id].add(new choose(in.nextInt(),in.nextInt()));
78             }
79             for(int i=1;i<time.length;i++)
80                 Collections.sort(list[i]);
81             int dp[]=new int[250];
82             Arrays.fill(dp,-1);
83             dp[0]=0;
84             int res=0;
85             for(int i=1;i<time.length;i++)
86             {
87                 rmq q=new rmq(list[i]);
88                 for(int j=list[i].get(list[i].size()-1).dead;j-time[i]>=0;j--)
89                 {
90                    if(dp[j-time[i]]!=-1&&(dp[j]==-1||dp[j]<dp[j-time[i]]+q.query(find(list[i],j))))
91                        dp[j]=dp[j-time[i]]+q.query(find(list[i],j));
92                 }
93             }
94             for(int i=0;i<dp.length;i++)
95                 res=Math.max(dp[i],res);
96             System.out.println(res);
97             System.out.println();
98         }
99
100     }
101
102 }
103

yzhw 2010-11-06 15:51 发表评论

pku 1661 Help Jimmy 线段树+阶段图DP

yzhw — Fri, 05 Nov 2010 07:47:00 GMT

"Help Jimmy" 是在下图所示的场景上完成的游戏。

场景中包括多个长度和高度各不相同的平台。地面是最低的平台，高度为零，长度无限。

Jimmy老鼠在时刻0从高于所有平台的某处开始下落，它的下落速度始终为1米/秒。当Jimmy落到某个平台上时，游戏者选择让它向左还是向右跑，它跑动的速度也是1米/秒。当Jimmy跑到平台的边缘时，开始继续下落。Jimmy每次下落的高度不能超过MAX米，不然就会摔死，游戏也会结束。

设计一个程序，计算Jimmy到底地面时可能的最早时间。

Input

第一行是测试数据的组数t（0 <= t <= 20）。每组测试数据的第一行是四个整数N，X，Y，MAX，用空格分隔。N是平台的数目（不包括地面），X和Y是Jimmy开始下落的位置的横竖坐标，MAX是一次下落的最大高度。接下来的N行每行描述一个平台，包括三个整数，X1[i]，X2[i]和H[i]。H[i]表示平台的高度，X1[i] 和X2[i]表示平台左右端点的横坐标。1 <= N <= 1000，-20000 <= X, X1[i], X2[i] <= 20000，0 < H[i] < Y <= 20000（i = 1..N）。所有坐标的单位都是米。

Jimmy的大小和平台的厚度均忽略不计。如果Jimmy恰好落在某个平台的边缘，被视为落在平台上。所有的平台均不重叠或相连。测试数据保证问题一定有解。

Output

对输入的每组测试数据，输出一个整数，Jimmy到底地面时可能的最早时间。

Sample Input

Sample Output

解法是这样

按照y坐标给每个区间排序，以线段端点为节点构图，每个节点最多有2条边，用线段树维护当前线段端点下方的线段。最后求最长路就可以了。

原来想简化，不要创建s和e节点，结果反而悲剧，各种漏考虑情况。。以后这类题目还是谨慎点吧。。

  1 # include <cstdio>
  2 # include <algorithm>
  3 # include <cstring>
  4 # define mid(p) ((st[p].s+st[p].e)>>1)
  5 # define abs(a) ((a)>0?(a):-(a))
  6 using namespace std;
  7 const int N=150000;
  8 int g[2005],nxt[5005],val[5005],v[5005],c,len[2005];
  9 struct
10 {
11    int s,e,id;
12 }st[N];
13 struct node
14 {
15    int h,s,e;
16 }data[1005];
17 int solve(int pos)
18 {
19     if(len[pos]!=-1) return len[pos];
20     else
21     {
22         if(g[pos]==-1) return pos?0xfffffff:0;
23         else
24         {
25             len[pos]=0xfffffff;
26             for(int p=g[pos];p!=-1;p=nxt[p])
27             {
28               len[pos]=min(len[pos],solve(v[p])+val[p]);
29             }
30             return len[pos];
31         }
32     }
33 }
34 bool cmp(const node &a,const node &b)
35 {
36    return a.h<b.h;
37 }
38 void init(int s,int e,int pos=1)
39 {
40    st[pos].s=s;
41    st[pos].e=e;
42    st[pos].id=-1;
43    if(e!=s+1)
44    {
45      init(s,mid(pos),pos<<1);
46      init(mid(pos),e,(pos<<1)+1);
47    }
48 }
49 int get(int target,int pos=1)
50 {
51     if(st[pos].id!=-1) return st[pos].id;
52     else if(target>=mid(pos)) return get(target,(pos<<1)+1);
53     else return get(target,(pos<<1));
54 }
55 void insert(int s,int e,int id,int pos=1)
56 {
57     if(st[pos].s==s&&st[pos].e==e)
58        st[pos].id=id;
59     else
60     {
61         if(st[pos].id!=-1)
62         {
63           st[pos<<1].id=st[(pos<<1)+1].id=st[pos].id;
64           st[pos].id=-1;
65         }
66         if(s>=mid(pos)) insert(s,e,id,(pos<<1)+1);
67         else if(e<=mid(pos)) insert(s,e,id,pos<<1);
68         else
69         {
70             insert(s,mid(pos),id,pos<<1);
71             insert(mid(pos),e,id,(pos<<1)+1);
72         }
73     }
74 }
75 inline void addedge(int s,int e,int len)
76 {
77    v[c]=e;
78    val[c]=len;
79    nxt[c]=g[s];
80    g[s]=c++;
81 }
82 int main()
83 {
84    int test;
85    scanf("%d",&test);
86    while(test--)
87    {
88        int n,x,y,maxnum;
89        scanf("%d%d%d%d",&n,&x,&y,&maxnum);
90        for(int i=1;i<=n;i++)
91        {
92           scanf("%d%d%d",&data[i].s,&data[i].e,&data[i].h);
93           data[i].s+=20000;
94           data[i].e+=20000;
95        }
96        x+=20000;
97        data[0].h=0;
98        sort(data+1,data+n+1,cmp);
99        init(0,40001);
100        insert(0,40001,0);
101        memset(g,-1,sizeof(g));
102        c=0;
103        for(int i=1;i<=n;i++)
104        {
105           int p=get(data[i].s);
106           if(data[i].h-data[p].h<=maxnum)
107           {
108                addedge(2*i-1,p?2*p-1:0,p?abs(data[i].s-data[p].s):0);
109                addedge(2*i-1,p?2*p:0,p?abs(data[i].s-data[p].e):0);
110           }
111           p=get(data[i].e);
112           if(data[i].h-data[p].h<=maxnum)
113           {
114               addedge(2*i,p?2*p-1:0,p?abs(data[i].e-data[p].s):0);
115               addedge(2*i,p?2*p:0,p?abs(data[i].e-data[p].e):0);
116           }
117           insert(data[i].s,data[i].e+1,i);
118        }
119        {
120         int p=get(x);
121         addedge(2*n+1,p?2*p-1:0,p?abs(x-data[p].s):0);
122         addedge(2*n+1,p?2*p:0,p?abs(x-data[p].e):0);
123        }
124        memset(len,-1,sizeof(len));
125        printf("%d\n",y+solve(2*n+1));
126    }
127    return 0;
128 }
129

yzhw 2010-11-05 15:47 发表评论

pku2168 Joke with Turtles 区间DP 注意~

yzhw — Mon, 01 Nov 2010 18:37:00 GMT

题目大意：

有N只可爱的小海龟在赛跑。询问每只小海龟它是第几名，它会回答你两个数，ai,bi，分别表示在它前面的小海龟数和在它后面的小海龟数。接着你发现其中有些小海龟对你撒了谎，因为根据他们的说法你根本没法给他们排队！但是你是善良的，你不希望有很多小海龟在撒谎，想找出最少有哪几只小海龟在撒谎。（注意：小海龟的名次可能是并列的！）

分析：

若一只海龟说了真话，那么该海龟的位置一定是在区间[ai+1,n-bi] 上。若有k只海龟选择了相同的区间，则根据并列关系，该区间最多能同时拥有min{n-ai-bi,k}只海龟（多出来的海龟肯定是说谎的，预先排除掉）。可以计算出每个区间最多能有多少只海龟，把数值看做区间的“权”。则问题转化为，在一些带权区间中，选出权和最大的区间，使它们之间不能互相重叠。

算法：

算出每个出现过的区间的“权”vi ，接下来的算法就是动态规划了。先按右端点坐标从小到大排序，令pi 为在区间 i左边的且与之无公共点的最大区间编号，设状态f[i] 为在前i 个区间中可选出区间的最大权和，则状态转移方程为f(i)=max(f(i-1),f(pi)+vi) ，说真话海龟的最大数量就是最后一个区间的f(i) 值。
论文：/Files/yzhw/range.rar

注意，在区间类问题中，要合理设计状态，究竟状态表示的是前i个区间（第i个区间不一定取）还是第i个区间一定要取的前i个区间。

1# include <iostream>
2# include <map>
3# include <vector>
4# include <cstring>
5# include <cstdio>
6using namespace std;
7vector<int> ans;
8map<int,vector<int> > refer;
9# define pos(a,b) (((b)<<10)|(a))
10struct node
11{
12   int s,e,val,per;
13}ran[1001];
14int dp[1001];
15int path[1001];
16bool used[1001];
17int c=1;
18int searchper(int pos)
19{
20    int s=1,mid,e=c;
21    e--;
22    while(s<=e)
23    {
24       mid=(s+e)/2;
25       if(ran[mid].e>=pos)
26         e=mid-1;
27       else
28         s=mid+1;
29    }
30    return e;
31}
32int main()
33{
34    int n;
35    scanf("%d",&n);
36    for(int i=0;i<n;i++)
37    {
38      int a,b;
39      scanf("%d%d",&a,&b);
40      if(a+b+1>n)
41        ans.push_back(i);
42      else
43      {
44        if(refer[pos(a+1,n-b)].size()<n-b-a)
45         refer[pos(a+1,n-b)].push_back(i);
46        else
47         ans.push_back(i);
48      }
49    }
50    for(map<int,vector<int> >::iterator i=refer.begin();i!=refer.end();i++)
51    {
52       ran[c].s=(i->first)&1023;
53       ran[c].e=((i->first)>>10);
54       ran[c++].val=(i->second).size();
55    }
56    for(int i=1;i<c;i++)
57      ran[i].per=searchper(ran[i].s);
58    dp[0]=0;
59    path[0]=-1;
60    for(int i=1;i<c;i++)
61    {
62       if(dp[i-1]>dp[ran[i].per]+ran[i].val)
63          path[i]=0,dp[i]=dp[i-1];
64       else
65          path[i]=1,dp[i]=dp[ran[i].per]+ran[i].val;
66    }
67    memset(used,false,sizeof(used));
68    int p=c-1;
69    while(p)
70    {
71      if(path[p])
72      {
73         used[p]=true;
74         p=ran[p].per;
75      }
76      else
77         p--;
78    }
79    for(int i=1;i<c;i++)
80      if(!used[i])
81         for(int j=0;j<refer[pos(ran[i].s,ran[i].e)].size();j++)
82            ans.push_back(refer[pos(ran[i].s,ran[i].e)][j]);
83    printf("%d",ans.size());
84      for(int i=0;i<ans.size();i++)
85       printf(" %d",ans[i]+1);
86      printf("\n");
87    return 0;
88}
89
90

yzhw 2010-11-02 02:37 发表评论

pku3171 Cleaning Shifts 区间最小权覆盖，DP+单调队列

yzhw — Mon, 01 Nov 2010 18:21:00 GMT

题意是这样：有N个牛，可以为FJ工作一段时间[s_i,t_i]，FJ要支付给他p_i工资。FJ需要整天都有牛为他工作，问他至少需要支付多少钱。
首先，可以对区间按照右端点为第一关键字排序，状态dp[pos]表示聘用第pos个牛时并且之前的区间都已经覆盖需要支付的钱，一个朴素的DP转移可以表示为
dp[pos]=min{dp[i]} e_i>=s_i。当然，我们立刻会发现一点，如果决策dp[j]>dp[i]，而jji，那么j这个决策是多余的。因此，我们可以维护一个单调队列，通过二分查找来找到满足e_i>=s_i的dp[i]最小值，整个算法复杂度nlogn。
具体分析见周大牛论文/Files/yzhw/range.rar

1import java.io.*;
2import java.util.*;
3class node implements Comparable<node>
4{
5    int s,e,val;
6    public int compareTo(node pos)
7    {
8        return e-pos.e;
9    }
10}
11public class Main {
12
13    /**
14     * @param args
15     */
16    static node arr[];
17    static int dp[];
18    static int stack[][],top=-1;
19    static int search(int pos)
20    {
21        int s=0,e=top,mid=0;
22        while(s<=e)
23        {
24            mid=(s+e)/2;
25            if(stack[mid][1]>=pos)
26                e=mid-1;
27            else
28                s=mid+1;
29        }
30        return s;
31    }
32    public static void main(String[] args) throws IOException{
33        Scanner in=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
34        int n=in.nextInt(),m=in.nextInt(),e=in.nextInt();
35        arr=new node[n];
36        dp=new int[n];
37        stack=new int[n][2];
38        for(int i=0;i<arr.length;i++)
39        {
40            arr[i]=new node();
41            arr[i].s=in.nextInt();
42            arr[i].e=in.nextInt();
43            if(arr[i].e<arr[i].s)
44            {
45                int t=arr[i].e;
46                arr[i].e=arr[i].s;
47                arr[i].s=t;
48            }
49            arr[i].val=in.nextInt();
50        }
51        Arrays.sort(arr);
52        int i,ans=Integer.MAX_VALUE;
53        for(i=0;arr[i].s>m&&i<n;i++);
54        if(i>=n||arr[n-1].e<e) System.out.println(-1);
55        else
56        {
57            dp[i]=arr[i].val;
58            if(arr[i].e>=e) ans=Math.min(ans, dp[i]);
59            stack[++top][0]=dp[i];
60            stack[top][1]=arr[i].e;
61            for(++i;i<n;i++)
62            {
63                int pos=search(arr[i].s-1);
64                if(pos>top)
65                    if(arr[i].s<=m)
66                        dp[i]=arr[i].val;
67                    else
68                        continue;
69                else
70                {
71                    dp[i]=stack[pos][0]+arr[i].val;
72                    if(arr[i].s<=m)
73                        dp[i]=Math.min(dp[i], arr[i].val);
74                }
75                while(top>=0&&stack[top][0]>=dp[i]) top--;
76                stack[++top][0]=dp[i];
77                stack[top][1]=arr[i].e;
78                if(arr[i].e>=e) ans=Math.min(ans, dp[i]);
79            }
80            if(ans==Integer.MAX_VALUE)
81                System.out.println(-1);
82            else
83                System.out.println(ans);
84        }
85
86
87    }
88
89}
90
91

yzhw 2010-11-02 02:21 发表评论

pku2342 Anniversary party 求树的最大权独立集

yzhw — Mon, 01 Nov 2010 17:48:00 GMT

题意简要的说就是给一棵树，求其最大权独立集。
树上的问题一般都可以用DP来解决。
设dp[pos]是以pos为根的最大权独立集，那么dp[pos]=max{val[pos]+dp[son[son[pos]]],dp[son[pos]]}
附代码

1# include <iostream>
2# include <cstdio>
3# include <vector>
4# include <cstring>
5# define N 10000
6# define max(a,b) ((a)>(b)?(a):(b))
7using namespace std;
8int val[N],dp[N],n;
9vector<int> g[N];
10using namespace std;
11int solve(int pos)
12{
13    if(dp[pos]!=-1) return dp[pos];
14    else
15    {
16        dp[pos]=0;
17        int total=val[pos];
18        for(int i=0;i<g[pos].size();i++)
19        {
20          dp[pos]+=solve(g[pos][i]);
21          for(int j=0;j<g[g[pos][i]].size();j++)
22            total+=solve(g[g[pos][i]][j]);
23        }
24        dp[pos]=max(dp[pos],total);
25        return dp[pos];
26
27    }
28}
29int main()
30{
31    scanf("%d",&n);
32    for(int i=1;i<=n;i++)
33       scanf("%d",val+i);
34    while(true)
35    {
36       int now,fa;
37       scanf("%d%d",&now,&fa);
38       if(!now&&!fa) break;
39       g[fa].push_back(now);
40    }
41    memset(dp,-1,sizeof(dp));
42    int total=-1;
43    for(int i=1;i<=n;i++)
44      if(dp[i]==-1)
45         total=max(total,solve(i));
46    printf("%d\n",total);
47 //   system("pause");
48    return 0;
49}
50

yzhw 2010-11-02 01:48 发表评论