C++博客-gzwzm06-文章分类-DP

7th GDCPC Problem G: Black Jack

Wed, 20 May 2009 07:53:00 GMT

  1#include >
  2#include
  3
  4const int SIZE = 1001;
  5
  6int N, arr[SIZE], dp[SIZE];
  7
  8int mark;
  9
10void DFS( const int& s, const int& banker, const int& mine, const int& bGet, const int& mGet, const int& state )
11{
12    if ( banker > 21 )
13    {
14        if ( dp[s - 1] < mark + 1 )
15            dp[s - 1] = mark + 1;
16    }
17    else if ( mine > 21 )
18    {
19        if ( dp[s - 1] < mark )
20            dp[s - 1] = mark;
21    }
22    else if ( s == N || !( bGet | mGet ) )
23    {
24        if ( banker >= mine )
25        {
26            if ( dp[s - 1] < mark )
27                dp[s - 1] = mark;
28        }
29        else if ( dp[s - 1] < mark + 1 )
30        {
31            dp[s - 1] = mark + 1;
32        }
33    }
34    else if ( state == 1 )
35    {
36        if ( banker < 16 )
37        {
38            if ( mGet )
39                DFS( s + 1, banker + arr[s], mine, bGet, mGet, 0 );
40            else
41                DFS( s + 1, banker + arr[s], mine, bGet, 0, 1 );
42        }
43        else {
44            DFS( s, banker, mine, 0, mGet, 0 );
45        }
46    }
47    else
48    {
49        if ( !bGet && banker < mine )
50        {
51            if ( dp[s - 1] < mark + 1 )
52                dp[s - 1] = mark + 1;
53        }
54        else
55        {
56            if ( bGet )
57            {
58                DFS( s, banker, mine, 1, 0, 1 );
59                DFS( s + 1, banker, mine + arr[s], 1, 1, 1 );
60            }
61            else
62            {
63                DFS( s, banker, mine, 0, 0, 1 );
64                DFS( s + 1, banker, mine + arr[s], 0, 1, 1 );
65            }
66        }
67
68    }
69}
70
71int main()
72{
73    freopen("1.txt", "r", stdin);
74
75    int i;
76
77    while ( scanf("%d", &N), N != 0 )
78    {
79        for ( i = 0; i < N; ++i )
80        {
81            scanf("%d", &arr[i]);
82        }
83
84        memset( dp, 0xff, sizeof(dp) );
85
86
87        mark = 0;
88        DFS( 4, arr[0] + arr[2], arr[1] + arr[3], 1, 1, 1 );
89
90        for ( i = 3; i < N - 5; ++i )
91        {
92            if ( dp[i] != -1 )
93            {
94                mark = dp[i];
95
96                DFS( i + 5, arr[i + 1] + arr[i + 3], arr[i + 2] + arr[i + 4], 1, 1, 1 );
97            }
98        }
99
100        int ans = 0;
101
102        for ( i = 0; i < SIZE; ++i )
103        {
104            if ( dp[i] > ans )
105                ans = dp[i];
106        }
107
108        printf("%d\n", ans);
109
110    }
111
112    return 0;
113}

巫 2009-05-20 15:53 发表评论

ZOJ 3187--Inviting Friends

Mon, 11 May 2009 13:47:00 GMT

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3187

  1#include <cstdio>
  2
  3const int SIZE = 101;
  4const int MAXS = 5000001;
  5
  6int N, M;
  7int food[SIZE], had[SIZE], need[SIZE];
  8int value[SIZE][2], cost[SIZE][2];
  9int arr[MAXS];
10
11int Cal(const int& p)
12{
13    int sum = 0;
14    int v, x, y;
15
16    arr[0] = 0;
17    for ( v = 1; v <= need[p] + value[p][1]; ++v )
18    {
19        arr[v] = -1;
20    }
21    for ( v = 0; v <= need[p] + value[p][1]; ++v )
22    {
23        x = value[p][0];
24        y = value[p][1];
25        if ( v - x >= 0 && arr[v - x] != -1 && (arr[v - x] + cost[p][0] < arr[v] || arr[v] == -1) )
26            arr[v] = arr[v - x] + cost[p][0];
27
28        if ( v - y >= 0 && arr[v - y] != -1 && (arr[v - y] + cost[p][1] < arr[v] || arr[v] == -1) )
29            arr[v] = arr[v - y] + cost[p][1];
30
31    }
32
33    sum = MAXS;
34    for ( v = need[p]; v <= need[p] + value[p][1]; ++v )
35    {
36        if ( arr[v] != -1 && arr[v] < sum )
37            sum = arr[v];
38    }
39
40    return sum;
41}
42bool Check(const int& limit)
43{
44    int i, C;
45
46    C = 0;
47    for ( i = 0; i < N; ++i )
48    {
49        need[i] = food[i] * limit - had[i] ;
50
51        C += Cal(i);
52
53        if ( C > M )
54            return false;
55
56    }
57
58    return true;
59}
60void Solve()
61{
62    int left = 1, right = M, mid;
63
64    while ( left <= right )
65    {
66        mid = (left + right) >> 1;
67
68        if ( Check(mid) )
69            left = mid + 1;
70        else
71            right = mid - 1;
72    }
73
74    printf("%d\n", left - 1);
75}
76
77int main()
78{
79    freopen("1.txt", "r", stdin);
80
81    int i;
82
83    while ( true )
84    {
85        scanf("%d %d", &N, &M);
86
87        if ( N == 0 && M == 0 )
88            break;
89
90        for ( i = 0; i < N; ++i )
91        {
92            scanf("%d %d", &food[i], &had[i]);
93            scanf("%d %d %d %d", &value[i][0], &cost[i][0], &value[i][1], &cost[i][1]);
94        }
95
96        Solve();
97    }
98
99    return 0;
100}

巫 2009-05-11 21:47 发表评论

zoj 3201 Tree of tree

Tue, 05 May 2009 01:39:00 GMT

求最大权值的子树

dp[root][i] = MAX{dp[root][j] + dp[child][i – j]}

其中 K >= i >= 2

表示以root为根，节点数为i 的子树的最大权值

1#include <cstdio>
2
3const int SIZE = 101;
4
5struct TREE
6{
7    int m_arr[SIZE];
8    int m_size;
9    int m_value;
10}tree[SIZE];
11
12int N, K;
13int dp[SIZE][SIZE];
14
15inline int MAX(const int& a, const int& b)
16{
17    return (a > b ? a : b);
18}
19
20void Init()
21{
22    int i;
23    for ( i = 0; i < SIZE; ++i )
24        tree[i].m_size = 0;
25}
26
27void DFS( const int& root, const int& fat )
28{
29    int i, j, k;
30
31    dp[root][0] = 0;
32    dp[root][1] = tree[root].m_value;
33    for ( i = 2; i <= K; ++i )
34        dp[root][i] = -1;
35
36    for ( i = 0; i < tree[root].m_size; ++i )
37    {
38        int x = tree[root].m_arr[i];
39
40        if ( x == fat )
41            continue;
42
43        DFS( x, root );
44
45        for ( j = K; j >= 2; --j )
46        {
47            int t = -1;
48            for ( k = 1; k <= j; ++k )
49            {
50                if ( dp[root][k] == -1 || dp[x][j - k] == -1 )
51                    continue;
52                t = MAX( t, dp[root][k] + dp[x][j - k] );
53            }
54            dp[root][j] = t;
55        }
56    }
57}
58
59void Solve()
60{
61    int ans = 0;
62
63    DFS( 0, -1 );
64
65    for ( int i = 0; i < N; ++i )
66        if ( ans < dp[i][K] )
67            ans = dp[i][K];
68
69    printf("%d\n", ans);
70}
71
72int main()
73{
74    //freopen("1.txt", "r", stdin);
75
76    int i, x, y;
77
78    while ( scanf("%d %d", &N, &K) != EOF )
79    {
80        Init();
81
82        for ( i = 0; i < N; ++i )
83            scanf("%d", &tree[i].m_value);
84
85        for ( i = 0; i < N - 1; ++i )
86        {
87            scanf("%d %d", &x, &y);
88            tree[x].m_arr[tree[x].m_size++] = y;
89            tree[y].m_arr[tree[y].m_size++] = x;
90        }
91
92        Solve();
93    }
94
95    return 0;
96}

巫 2009-05-05 09:39 发表评论

POJ 3211 Washing Clothes

Sun, 03 May 2009 03:03:00 GMT

1#include <cstdio>
2#include <cstring>
3
4const int SIZE = 101;
5const int MAX = 1000001;;
6
7int M, N;
8int arr[10][SIZE], size[10], sum[10];
9char cloth[10][11];
10bool dp[MAX];
11
12int GetType(const char* str)
13{
14    int i;
15    for ( i = 0; i < M; ++i )
16        if ( strcmp(str, cloth[i]) == 0 )
17            break;
18
19    return i;
20}
21
22void Solve()
23{
24    int i, v, n, t, limit;
25    int time = 0;
26
27    for ( n = 0; n < M; ++n )
28    {
29        memset(dp, 0, sizeof(dp));
30        dp[0] = true;
31
32        t = 0;
33        limit = sum[n] >> 1;                //01背包：dp出最接近 sum / 2 的值
34        for ( i = 0; i < size[n]; ++i )
35        {
36            for ( v = limit; v >= arr[n][i]; --v )
37            {
38
39                if ( dp[v - arr[n][i]] )
40                {
41                    dp[v] = true;            //对该位置标志
42                    if ( v > t )
43                    {
44                        t = v;
45                    }
46                }
47
48            }
49        }
50
51        time += (sum[n] - t);    //须取最大的值
52    }
53
54
55    printf("%d\n", time);
56}
57
58int main()
59{
60//    freopen("1.txt", "r", stdin);
61
62    int i, j, n;
63    char str[11];
64
65    while ( scanf("%d %d", &M, &N) != EOF )
66    {
67        if ( M == 0 && N == 0 )
68            break;
69
70        for ( i = 0; i < M; ++i )
71        {
72            size[i] = 0;
73            sum[i] = 0;
74            scanf("%s", cloth[i]);
75        }
76
77        for ( i = 0; i < N; ++i )
78        {
79            scanf("%d %s", &n, str);
80
81            j = GetType( str );
82            arr[j][size[j]++] = n;
83            sum[j] += n;
84        }
85
86        Solve();
87    }
88
89    return 0;
90}

巫 2009-05-03 11:03 发表评论

POJ 3254 Corn Fields

Sat, 02 May 2009 02:51:00 GMT

1//状态压缩
2#include <cstdio>
3
4int N, M;
5
6struct ITEM
7{
8    int m_arr[1024];
9    int m_size;
10}item[13];
11
12int dp[13][1024];
13
14//生成每行的所有合法状态
15//参数：pos 代表行 illegal代表不合法的状态(源行为0的状态)
16void GetState(const int& pos, const int& illegal)
17{
18    int state, n;
19
20    n = 0;
21    for ( state = 0; state < (1 << N); ++state )        //从0开始枚举到(1 << N): N = 3时, 000-->111 ((1 << N)8 - 1)
22    {
23        if ( (state << 1) & state || (state >> 1) & state ) //去除相邻都为1的状态
24            continue;
25        if ( state & illegal )    //去除原为0的状态
26            continue;
27
28        item[pos].m_arr[n++] = state;
29    }
30
31    item[pos].m_size = n;
32}
33
34void Solve()
35{
36    int i, j, k;
37
38    //初始化：首行的每个合法状态必为1
39    for ( i = 0; i < item[0].m_size; ++i )
40        dp[0][i] = 1;
41
42    //状态方程：dp[i][j] = SUM{dp[i - 1][k]}
43    for ( i = 1; i < M; ++i )
44    {
45        for ( j = 0; j < item[i].m_size; ++j )
46        {
47            dp[i][j] = 0;
48            for ( k = 0; k < item[i - 1].m_size; ++k )
49            {
50                //与上一行冲突
51                if ( item[i].m_arr[j] & item[i - 1].m_arr[k] )
52                    continue;
53                dp[i][j] += dp[i - 1][k];
54            }
55        }
56    }
57
58    int result = 0;
59    for ( i = 0; i < item[M - 1].m_size; ++i )
60    {
61        result += dp[M - 1][i];
62        result %= 100000000;
63    }
64
65    printf("%d\n", result);
66}
67
68int main()
69{
70//    freopen("1.txt", "r", stdin);
71    int i, j, state, illegal;
72
73    scanf("%d %d", &M, &N);
74
75    for ( i = 0; i < M; ++i )
76    {
77        illegal = 0;
78        for ( j = 0; j < N; ++j )
79        {
80            scanf("%d", &state);
81            //取反状态
82            illegal = (illegal << 1) + 1 - state;
83        }
84
85        GetState( i, illegal );
86    }
87
88    Solve();
89
90    return 0;
91}

巫 2009-05-02 10:51 发表评论

POJ 3670 Eating Together(最长非递增（非递减）子序列)

Sun, 22 Mar 2009 11:55:00 GMT

先求出最长非递增子序列和最长非递减子序列，由总长度减去其中较长的一个

1#include <cstdio>
2#include <algorithm>
3#include <vector>
4#include <list>
5#include <iterator>
6#include <limits>
7using namespace std;
8
9const int SIZE = 30010;
10
11template<typename T>
12int LIS(T Array[], int nCnt)
13{
14    if (nCnt == 0)
15        return 0;
16
17    Array[nCnt++] = numeric_limits<T>::max();
18
19    T *p = Array;
20    vector<T> dp;
21    dp.push_back(p[0]);
22    int nRet = 1;
23    for (int n = 1; n < nCnt; ++n)
24    {
25        T& e = p[n];
26        typename vector<T>::iterator itor = upper_bound(dp.begin(), dp.end(), e, less<int>());
27
28        if ( itor == dp.end() )
29            dp.push_back(e);
30        else if (*itor > e)
31            *itor = e;
32    }
33
34    return ((int)dp.size() - 1) ;
35}
36
37template<typename T>
38int LDS(T Array[], int nCnt)
39{
40    Array[nCnt++] = numeric_limits<T>::min();
41
42    T *p = Array;
43    vector<T> dp;
44    dp.push_back(p[0]);
45    int nRet = 1;
46    for (int n=1; n < nCnt; ++n)
47    {
48        T& e = p[n];
49        typename vector<T>::iterator itor = upper_bound(dp.begin(), dp.end(), e, greater<int>());
50
51        if ( itor == dp.end() )
52            dp.push_back(e);
53        else if (*itor < e)
54            *itor = e;
55    }
56
57    return (int)dp.size()-1;
58}
59
60int array[SIZE];
61
62int main()
63{
64    int i, n, lis, lds;
65
66    scanf("%d", &n);
67
68    for ( i = 0; i < n; ++i )
69    {
70        scanf("%d", &array[i]);
71    }
72
73    lis = LIS(array, n);
74    lds = LDS(array, n);
75
76    int ans = (lis > lds ? lis : lds);
77
78    printf("%d\n", n - ans);
79    return 0;
80}

巫 2009-03-22 19:55 发表评论

POJ 3661-Running

Thu, 19 Mar 2009 15:12:00 GMT

dp[i][j]:第i分钟疲劳度为j时的最大路径值
转移方程：
dp[i][j] = dp[i - 1][j - 1] + distance[i] ( j > 0 )
dp[i][0] = max (dp[i - 1][0], dp[i - j][j](i - j >= j && j <= M))

1#include
2
3const int SIZE_T = 10001;
4const int SIZE_M = 501;
5
6int dp[SIZE_T][SIZE_M];
7
8int T, M, dist[SIZE_T];
9
10void Solve()
11{
12    int i, j;
13
14    for ( i = 0; i <= M; ++i )
15        dp[0][i] = 0;
16
17    for ( i = 1; i <= T; ++i )
18    {
19        dp[i][0] = dp[i - 1][0];
20        for ( j = 1; i - j >= j && j <= M; ++j )
21        {
22            dp[i][0] = (dp[i][0] > dp[i - j][j] ? dp[i][0] : dp[i - j][j] );
23        }
24
25        for ( j = 1; j <= M; ++j )
26        {
27            dp[i][j] = dp[i - 1][j - 1] + dist[i];
28
29        }
30    }
31
32    printf("%d\n", dp[T][0]);
33}
34
35int main()
36{
37    int i;
38    scanf("%d %d", &T, &M);
39
40    for ( i = 1; i <= T; ++i )
41        scanf("%d", &dist[i]);
42
43    Solve();
44
45    return 0;
46}

巫 2009-03-19 23:12 发表评论

Pku 3494--Largest Submatrix of All 1’s(路径压缩)

Fri, 06 Mar 2009 03:10:00 GMT

摘要: 1#include 2#include 3 4const int MAXN = 4008 ; 5const int... 阅读全文

巫 2009-03-06 11:10 发表评论

PKU 1964--City Game(栈模拟)

Thu, 05 Mar 2009 15:56:00 GMT

摘要: 用PKU 2559的思路跟2559一样还有DP解法：路径压缩 1 2#include 3#include 4 5const int SIZE = 1002 ... 阅读全文

巫 2009-03-05 23:56 发表评论

POJ 2559--Largest Rectangle in a Histogram(栈模拟)

Thu, 05 Mar 2009 15:17:00 GMT

1//栈模拟---157ms
2//更好的方法，也许是DP吧
3
4#include <cstdio>
5
6const int SIZE = 100001 ;
7
8struct STACK
9{
10    __int64 ht ;
11    int pos ;
12} ;
13
14STACK stack[SIZE] ;
15int top ;
16
17int N ;
18__int64 height[SIZE] ;
19
20__int64 GetMaxArea()
21{
22    __int64 ans , temp ;
23    int i ;
24
25    top  = 0 ;
26
27    stack[top].ht = height[0] ;
28    stack[top].pos = 0 ;
29    ans = height[0] ;
30    height[N] = 0 ;
31
32    for ( i = 1 ; i <= N ; ++i )
33    {
34        if ( height[i] <= stack[top].ht )
35        {
36            while ( top >= 0 && height[i] <= stack[top].ht )
37            {
38                temp = stack[top].ht * (i - stack[top].pos) ;
39
40                if ( temp > ans )
41                    ans = temp ;
42
43                top-- ;
44            }
45            top++ ;
46            stack[top].ht = height[i] ;
47        }
48        else {
49            stack[++top].ht = height[i] ;
50            stack[top].pos = i ;
51        }
52    }
53
54    return ans ;
55}
56
57int main()
58{
59//    freopen("1.txt", "r", stdin) ;
60
61    int i ;
62
63    while ( scanf("%d", &N) && N != 0 )
64    {
65        for ( i = 0 ; i < N ; ++i )
66        {
67            scanf("%I64d", &height[i]) ;
68        }
69
70        __int64 ans = GetMaxArea() ;
71
72        printf("%I64d\n", ans) ;
73    }
74
75    return 0 ;
76}

巫 2009-03-05 23:17 发表评论

Pku 1080--Human Gene Functions

Fri, 31 Oct 2008 12:16:00 GMT

#include <stdio.h>

const int Table[5][5] = { 5, -1, -2, -1, -3,
            -1, 5, -3, -2, -4,
            -2, -3, 5, -2, -2,
            -1, -2, -2, 5, -1,
            -3, -4, -2, -1, 0

} ;

const int MAXN = 102 ;

int Ctoi( char &c )
{
    switch( c )
    {
    case 'A':
        return 0 ;
    case 'C':
        return 1 ;
    case 'G':
        return 2 ;
    case 'T':
        return 3 ;
    }
    return -1 ;
}

int main()
{
    int N , m , n , i , j , Ftmp[MAXN] , Stmp[MAXN] ;
    int mem[MAXN][MAXN] ;
    char str1[MAXN], str2[MAXN] ;
    scanf("%d", &N) ;

    for ( i = 0 ; i < N ; ++i )
    {
        scanf("%d %s", &m, &str1) ;
        scanf("%d %s", &n, &str2) ;

        for ( j = 0 ; j < m ; ++j )
        {
            Ftmp[j + 1] = Ctoi( str1[j] ) ;
        }
        for ( j = 0 ; j < n ; ++j )
        {
            Stmp[j + 1] = Ctoi( str2[j] ) ;
        }

        mem[0][0] = 0 ;

        for ( j = 1 ; j <= m ; ++j )
        {
            mem[j][0] = mem[j - 1][0]+ Table[4][Ftmp[j]] ;
        }
        for ( j = 1 ; j <= n ; ++j )
        {
            mem[0][j] = mem[0][j - 1] + Table[4][Stmp[j]] ;
        }

        int k ;

        for ( j = 1 ; j <= m ; ++j )
            for ( k = 1 ; k <= n ; ++k )
            {
                mem[j][k] = mem[j - 1][k - 1] + Table[Ftmp[j]][Stmp[k]] ;
                if ( mem[j][k] < mem[j - 1][k] + Table[Ftmp[j]][4] )
                    mem[j][k] = mem[j - 1][k] + Table[Ftmp[j]][4] ;
                if ( mem[j][k] < mem[j][k - 1] + Table[4][Stmp[k]] )
                    mem[j][k] = mem[j][k - 1] + Table[4][Stmp[k]] ;
            }

        printf("%d\n", mem[m][n]) ;
    }
    return 0 ;
}

巫 2008-10-31 20:16 发表评论

Pku 1836--Alignment

Wed, 29 Oct 2008 15:38:00 GMT

最长递增子序列

#include <stdio.h>

const int MAXN = 1001 ;

int n ;
int array[MAXN] ;
int memfp[MAXN] , membp[MAXN] ;

int main()
{
    int i , j , tmp , ans ;
    while ( scanf("%d", &n) != EOF )
    {
        for ( i = 0 ; i < n ; ++i )
        {
            scanf("%d", &array[i]) ;
            memfp[i] = 1 ;
            for ( j = 0 ; j < i ; ++j )
            {
                if ( array[i] > array[j] && memfp[j] + 1 > memfp[i] )
                {
                    memfp[i] = memfp[j] + 1 ;
                }
            }
        }

        for ( i = n - 1; i >= 0; --i )
        {
            membp[i] = 1 ;
            for ( j = n - 1; j > i ; --j )
            {
                if ( array[i] > array[j] && membp[j] + 1 > membp[i] )
                    membp[i] = membp[j] + 1 ;
            }
        }
        ans = 0 ;
        for ( i = 0 ; i < n ; ++i )
        {
            tmp = 0 ;
            for ( j = i + 1 ; j < n ; ++j )
            {
                if ( array[i] >= array[j] )
                    tmp = (tmp > membp[j] ? tmp : membp[j]) ;

            }
            ans = ( memfp[i] + tmp > ans ? memfp[i] + tmp : ans ) ;
        }

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

巫 2008-10-29 23:38 发表评论