BlogJava-土人的家-随笔分类-DP

TheSumOfLuckyNumbers

jav7er — Fri, 25 Dec 2009 08:13:00 GMT

TopCoder SRM 403 Level2 1000
4和7是幸运数字，如果一个数只包含4和7，那么这个数字也是一个幸运数字
给定一个1－1,000,000的数字，求这个数字是否可以仅由幸运数字相加得出，返回所有的幸运数字加数，如果有多组解，返回加数最少的一组

以前没有遇到过这样的DP题目
这题加深了我对于“每个子问题的答案都是最佳答案”的理解
首先是额外的计算
将范围以内的幸运数字打表
然后从输入数字N开始递减DP计算
N的步数为0
如果最后0的步数为正数
说明有解
再从0开始递增寻找解的路径

不过这个方法最后也没有通过tc的系统测试
数字一大就超时了
后面又时间再研究一下
看看有没有办法在改进

1 import java.util.*;
2 import java.util.regex.*;
3 import java.text.*;
4 import java.math.*;
5 import java.awt.geom.*;
6
7 public class TheSumOfLuckyNumbers
8 {
9
10     public int[] sum(int n)
11     {
12         ArrayList<Integer> table = calTable();
13         int[] dp = new int[n+1];
14         Arrays.fill(dp, Integer.MAX_VALUE-10);
15         dp[n] = 0;
16         int i , j;
17         for(i = n; i > 0 ; -- i){
18             for(int lucky:table){
19                 if(i - lucky >=0 && dp[i] + 1 < dp[i - lucky])
20                     dp[i - lucky] = dp[i] + 1;
21             }
22         }
23         if(dp[0] == Integer.MAX_VALUE)
24             return new int[0];
25         ArrayList<Integer> ans = new ArrayList<Integer>();
26         int total = dp[0]-1;
27         for(i = 0 ; i <= n; ++ i){
28             for(int lucky:table){
29                 if(i + lucky <= n && dp[i + lucky] == total){
30                     ans.add(lucky);
31                     i += lucky-1;
32                     total--;
33                     break;
34                 }
35             }
36         }
37         int[] ret = new int[ans.size()];
38         for(i = 0 ; i < ans.size(); ++ i)
39             ret[i] = ans.get(i);
40         return ret;
41     }
42
43
44
45     public ArrayList<Integer> calTable(){
46         ArrayList<Integer> table = new ArrayList<Integer>();
47         table.add(4);
48         table.add(7);
49         int i = 1;
50         while(i < 7){
51             ArrayList<Integer> temp = new ArrayList<Integer>();
52             for(int j = 0 ; j < table.size(); ++ j){
53                 int newItem = table.get(j) * 10;
54
55                 temp.add(newItem+4);
56                 temp.add(newItem+7);
57             }
58             i++;
59             table.addAll(temp);
60         }
61         return table;
62     }
63 }

jav7er 2009-12-25 16:13 发表评论

CollectingMarbles

jav7er — Tue, 15 Dec 2009 07:15:00 GMT

TopCoder SRM 397 Level2 1000
http://www.topcoder.com/stat?c=problem_statement&pm=8746
一个彩球集合，重量各不相同，给定容器大小如何带回尽量多的彩球

限制条件中彩球个数小于13
因此用DP来计算复杂度为2^13*20*10是可以接受的
这一题用memo方法更加合适因为会有大量的数据不需要计算
每一次都迭代计算所有未填的球
把球放进口袋或者直接开始填下一袋
DP三个参数是mask，剩余袋数和本袋剩余空间

1import java.util.*;
2import java.util.regex.*;
3import java.text.*;
4import java.math.*;
5import java.awt.geom.*;
6
7public class CollectingMarbles
8{
9    int[][][] dic;
10    int L;
11    int[] mw;
12    int bagNumber;
13    int cap;
14
15    public int mostMarbles(int[] marblesWeights, int bagCapacity, int numberOfBags)
16    {
17        L = marblesWeights.length;
18        mw = marblesWeights;
19        bagNumber = numberOfBags;
20        cap = bagCapacity;
21        dic = new int[1<<L][bagNumber+1][cap+1];
22        for(int[][] a : dic)
23            for(int[] b : a)
24                Arrays.fill(b, -1);
25        int ans = recur(0, bagNumber, cap);
26        return ans == -1? 0 : ans;
27    }
28
29    private int recur(int mask, int bagNumber, int cur) {
30        // TODO Auto-generated method stub
31        if(bagNumber == 0)
32            return 0;
33        if(dic[mask][bagNumber][cur] > -1)
34            return dic[mask][bagNumber][cur];
35        dic[mask][bagNumber][cur] = 0;
36        for(int i = 0 ; i < L ; ++ i){
37            if((mask & (1 << i)) == 0 && mw[i] <= cur){
38                dic[mask][bagNumber][cur] = Math.max(dic[mask][bagNumber][cur],
39                        1+recur(mask|1<<i, bagNumber, cur-mw[i]));
40
41            }
42            dic[mask][bagNumber][cur] = Math.max(dic[mask][bagNumber][cur],
43                    recur(mask, bagNumber-1, cap));
44        }
45
46        return dic[mask][bagNumber][cur];
47    }
48}

jav7er 2009-12-15 15:15 发表评论

TriviaGame

jav7er — Wed, 18 Nov 2009 12:24:00 GMT

TopCoder SRM 395 Level2 1000
http://www.topcoder.com/stat?c=problem_statement&pm=8463&rd=11129
标准的DP题目

在运算中几处忽略了比较检查，特殊值
导致错误了两次
做题目在主要思路有了之后还是要仔细考虑特殊情况
往往人家关注的地方就在这里

1import java.util.*;
2import java.util.regex.*;
3import java.text.*;
4import java.math.*;
5import java.awt.geom.*;
6
7public class TriviaGame
8{
9    public int maximumScore(int[] points, int tokensNeeded, int[] bonuses)
10    {
11        int L = points.length;
12        int[][] dic = new int[L][tokensNeeded+1];
13        for(int[] i:dic)
14            Arrays.fill(i, -100000);
15        int i;
16        dic[0][0] = -1 * points[0];
17        dic[0][1] = points[0];
18        if(tokensNeeded == 1)
19            dic[0][0] = dic[0][1]+bonuses[0];
20        for(i = 1; i < L; ++ i){
21            if(dic[i-1][0] - points[i] > dic[i][0])
22                dic[i][0] = dic[i-1][0] - points[i];
23            int j;
24            for(j = 1; j < Math.min(i+2, tokensNeeded); ++ j){
25                int a = dic[i-1][j-1] + points[i];
26                int b = dic[i-1][j] - points[i];
27                dic[i][j] = Math.max(a, b);
28            }
29            if(j == tokensNeeded){
30                dic[i][j] = dic[i-1][j-1] + points[i];
31                dic[i][j] += bonuses[i];
32                if(i != L - 1 && dic[i][j] > dic[i][0])
33                    dic[i][0] = dic[i][j];
34            }
35
36        }
37        int max = dic[L-1][0];
38        for(int in:dic[L-1])
39            if(in > max)
40                max = in;
41        return max;
42    }
43}

jav7er 2009-11-18 20:24 发表评论

SetOfPatterns

jav7er — Mon, 16 Nov 2009 14:04:00 GMT

TopCoder SRM 390 Level2 1000
http://www.topcoder.com/stat?c=problem_statement&pm=8307&rd=11124
一组Pattern，每个位上是字母或者通配符“？”，求恰好符合K个Pattern的字符串数

这个题目麻烦在恰好（exactly）上
否则完全可以暴力处理
这里要恰好，即符合K个而不符合K＋1个
用DP逐个位置处理
计算出每个字母匹配的Pattern集合，再和前面的Pattern集合取交集计算这一行的结果
计算过程中取交集的“&”错写成了“|” 太生疏了

1import java.util.*;
2import java.util.regex.*;
3import java.text.*;
4import java.math.*;
5import java.awt.geom.*;
6
7public class SetOfPatterns
8{
9    public int howMany(String[] patterns, int k)
10    {
11        int[][] tab = new int[50][1<<15];
12        int L = patterns.length;
13        int T = 1 << L;
14
15        for(int[] i:tab)
16            Arrays.fill(i, 0);
17        int i,j;
18        char c;
19        for(i = 0 ; i < patterns[0].length(); ++ i){
20
21            for(c = 'a'; c <= 'z'; ++ c){
22                int mask = 0 ;
23                for(j = 0 ; j < L ; ++ j){
24                    if(patterns[j].charAt(i) == c || patterns[j].charAt(i) =='?')
25                        mask |= 1 << j;
26                }
27                if(i == 0){
28                    tab[i][mask]++;
29                }
30                else{
31                    for(j = 0 ; j < (T); ++ j){
32                        int fin = j & mask;
33                        tab[i][fin] = (tab[i][fin] + tab[i-1][j])%1000003;
34                    }
35                }
36            }
37        }
38        int ans=0;
39        for(i = 0 ; i < T; ++ i){
40            int cnt = 0;
41            for(j = 0 ; j < L; ++ j){
42                int temp = i & (1 << j);
43                if(temp != 0)
44                    cnt ++;
45            }
46            if(cnt == k)
47                ans = (ans + tab[patterns[0].length()-1][i]) % 1000003;
48        }
49        return ans;
50    }
51}

jav7er 2009-11-16 22:04 发表评论