C++博客-purplest-随笔分类-DP

hdu 4109 Instrction Arrangement

purplest — Mon, 31 Oct 2011 07:58:00 GMT

一道类似拓扑排序的思路了

开始直接裸的拓扑，结果TLE死。。。

想了很久，改了个加上了个记忆化，171ms搞定了。。。

#include <stdio.h>
#include <string.h>

struct P
{
    int hasfa, haschild, flag;
    int child[1010], index[1010];
}data[1010];

int n, m;
int dp[1010];

int max(int a, int b)
{
    return a>b?a:b;
}

int dfs(int i)
{
    if ( dp[i] )
        return dp[i];
    if ( data[i].haschild )
    {
        int maxn= 0;
        for ( int j = 0 ; j < data[i].flag ; j++ )
        {
            int t= dfs(data[i].index[j])+data[i].child[data[i].index[j]];
            maxn= max( maxn , t );
        }
        return dp[i]= maxn;
    }
    else
        return dp[i]=1;
}

int main()
{
    while ( EOF != scanf("%d%d", &n, &m) )
    {
        int i, u, s, t;
        memset(data, 0, sizeof(P)*n);
        memset(dp, 0, sizeof(dp));
        for ( i = 0 ; i < m ; i++ )
        {
            scanf("%d%d%d", &u, &s, &t);
            data[s].hasfa= 1;
            data[u].haschild= 1;
            data[u].child[s]= t;
            data[u].index[data[u].flag++]= s;
        }
        for ( i = 0 ; i < n ; i++ )
        {
            if ( !data[i].hasfa )
                dp[i]=dfs(i);
        }
        int maxn= 0;
        for ( i = 0 ; i < n ; i++ )
            maxn= max(maxn , dp[i]);
        printf("%d\n", maxn);
    }
    return 0;
}

purplest 2011-10-31 15:58 发表评论

poj 1036 Gangsters

purplest — Mon, 03 Oct 2011 12:13:00 GMT

果的dp

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int n, k, t;
int dp[110];
struct P
{
    int times, value, fat;
}node[110];

int myabs(int a)
{
    return a>0?a:-a;
}

int cmp( const void* a, const void* b )
{
    return (*(P*)a).times-(*(P*)b).times;
}

int main()
{
    while ( 3 == scanf("%d%d%d", &n, &k, &t) )
    {
        int i, j, max= 0;
        for ( i = 1 ; i <= n ; i++ )
            scanf("%d", &node[i].times);
        for ( i = 1 ; i <= n ; i++ )
            scanf("%d", &node[i].value);
        for ( i = 1 ; i <= n ; i++ )
            scanf("%d", &node[i].fat);
        qsort(node+1, n, sizeof(P), cmp);
        node[0].value= node[0].fat= node[0].times= 0;
        memset(dp, -1, sizeof(dp));
        dp[0]= 0;
        for ( i = 1 ; i <= n ; i++ )
        {
            for ( j = 0 ; j < i ; j++ )
                if ( myabs(node[i].times-node[j].times) >= myabs(node[i].fat-node[j].fat) && dp[i] < dp[j] )
                    dp[i]= dp[j];
            if ( dp[i] != -1 )
                dp[i]+=node[i].value;
            if ( max < dp[i] )
                max= dp[i];
        }
        printf("%d\n", max);
    }
    return 0;
}

purplest 2011-10-03 20:13 发表评论

uva 10405 Longest Common Subsequence

purplest — Fri, 09 Sep 2011 13:20:00 GMT

果的LCS，输入有trick，可能遇到空格，不能用scanf，当然，正则表达式也行

#include <stdio.h>
#include <string.h>

char str1[1010], str2[1010];
int data[1010][1010];

int max(int a, int b)
{
    return a>b?a:b;
}

int LCS()
{
    int len1= strlen(str1)-1, len2= strlen(str2)-1;
    int i, j;
    for ( i = max(len1, len2) ; i >= 0 ; i-- )
        data[i][0]= data[0][i]= 0;
    for ( i = 1 ; i <= len1 ; i++ )
        for ( j = 1 ; j <= len2 ; j++ )
            if ( str1[i-1] == str2[j-1] )
                data[i][j]= data[i-1][j-1]+1;
            else
                data[i][j]= max(data[i-1][j], data[i][j-1]);
    return data[len1][len2];
}

int main()
{
    while ( NULL != fgets(str1, sizeof(str1), stdin) )
    {
        fgets(str2, sizeof(str2), stdin);
        printf("%d\n", LCS());
    }
    return 0;
}

PS:fgets会把\n也读进来

purplest 2011-09-09 21:20 发表评论

uva 103 Stacking Boxes

purplest — Fri, 09 Sep 2011 10:23:00 GMT

LIS有点小改动，比较的时候必须完全大于

#include<stdio.h>
#include<stdlib.h>

const int M=31;

int num[M][M], path[M], index[M];
int n, m, len;

int cmpnum(const void *a, const void *b)
{
    return *(int *)a-*(int *)b;
}

int cmpindex(const void *a, const void *b)
{
    return num[*(int *)a][0] - num[*(int *)b][0];
}

void print(int k, int lens)
{
    if ( k < 0 || !len ) return;
    print(path[k], len-1);
    printf("%d", k+1);
    len == lens ? putchar(10) : putchar(' ');
}

int judge(int j, int k)
{
    for ( int i = 0 ; i < m ; i++ )
        if ( num[j][i] <= num[k][i] )
            return 0;
    return 1;
}

int main()
{
    while( 2 == scanf("%d%d", &n, &m) )
    {
        int dp[M], i, j;
        for ( i = 0 ; i < n ; i++ )
        {
            index[i]= i; dp[i]= 1 ; path[i]= -1;
            for ( j = 0 ; j < m ; j++ )
                scanf("%d", num[i]+j);
            qsort(num[i], m, sizeof(int), cmpnum);
        }
        qsort(index, n, sizeof(int), cmpindex);
        int k= 0;
        len= 1;
        for ( i = 1 ; i < n ; i++ )
        {
            for ( j = 0 ; j < i ; j++ )
            {
                if ( judge(index[i], index[j]) && dp[i] < dp[j]+1 )
                {
                    dp[i]= dp[j]+1;
                    path[index[i]]=index[j];
                }
            }
            if (dp[i] > len)
            {
                len= dp[i];
                k= index[i];
            }
        }
        printf("%d\n", len);
        print(k, len);
    }
    return 0;
}

purplest 2011-09-09 18:23 发表评论

uva 111 History Grading

purplest — Fri, 09 Sep 2011 10:20:00 GMT

果的LCS，只不过输入的时候有trick

#include <stdio.h>

int n;
int str1[50], str2[50];

int LCS()
{
    int dp[50][50], i, j;
    for ( i = 0 ; i <= n ; i++ )
        dp[i][0]= dp[0][i] = 0;
    for ( i = 1 ; i <= n ; i++ )
        for ( j = 1 ; j <= n ; j++ )
            if (str1[i] == str2[j])
                dp[i][j]= dp[i-1][j-1]+1;
            else
                dp[i][j]= dp[i-1][j] > dp[i][j-1] ? dp[i-1][j] : dp[i][j-1];
    return dp[n][n];
}

int main()
{
    scanf("%d", &n);
    int i, t;
    for ( i = 0 ; i < n ; i++ )
    {
        scanf("%d", &t);
        str1[t]= i+1;
    }
    while ( EOF != scanf("%d", &t) )
    {
        str2[t]= 1;
        for ( i = 1 ; i < n ; i++ )
        {
            scanf("%d", &t);
            str2[t]= i+1;
        }
        printf("%d\n", LCS());
    }
    return 0;
}

purplest 2011-09-09 18:20 发表评论

poj 1664 放苹果

purplest — Tue, 06 Sep 2011 09:46:00 GMT

一道比较水的题，数据范围很小，打表能过，不过其中的递归思想很不错，很有dp的感觉

int dfs(int m, int n)
{
    if ( m == 0 || n == 1 )
        return 1;
    if ( m < n )
        return dfs(m, m);
    return dfs(m, n-1)+dfs(m-n, n);
}

这不就是dp了么？边界条件+处理当前状况

#include <stdio.h>

int dfs(int m, int n)
{
    if ( m == 0 || n == 1 )
        return 1;
    if ( m < n )
        return dfs(m, m);
    return dfs(m, n-1)+dfs(m-n, n);
}

int main()
{
    int ncase, m, n;
    scanf("%d", &ncase);
    while ( ncase-- )
    {
        scanf("%d%d", &m, &n);
        printf("%d\n", dfs(m, n));
    }
    return 0;
}

purplest 2011-09-06 17:46 发表评论

poj 1221 UNIMODAL PALINDROMIC DECOMPOSITIONS

purplest — Sun, 14 Aug 2011 16:18:00 GMT

处理回文，可dp

#include <stdio.h>
#include <string.h>
__int64 num[300][300];

int main()
{
    memset(num, 0, sizeof(num));
    int i, j;
    for ( i = 0; i < 300; i++ )
    {
        num[0][i]= 1;
        for ( j = i ; j >= 0 ; j--)
            num[i][j]= 1;
    }
    for ( i = 2 ; i < 300 ; i++ )
        for ( j = i/2; j > 0; j-- )
            num[i][j]= num[i-2*j][j]+num[i][j+1];
    int n;
    while ( scanf("%d", &n), n)
    {
        printf("%d %I64d\n", n, num[n][1]);
    }
    return 0;
}

purplest 2011-08-15 00:18 发表评论

poj 2411 Mondriaan's Dream

purplest — Fri, 05 Aug 2011 15:23:00 GMT

DFS+DP压缩状态，二进制优化处理

#include <stdio.h>
#include <string.h>

long long a[2][1<<11];
int n, m, t;

void init(int d, int last)
{
    if ( d == m )
    {
        a[0][last]++;
        return;
    }
    if ( d+1 <= m )
        init(d+1, last<<1);
    if ( d+2 <= m )
        init(d+2, last<<2|3);
}
void dfs( int d, int last, int now )
{
    if ( d == m )
    {
        a[t][now] += a[(t+1)%2][last];
        return;
    }
    if ( d+1 <= m)
    {
        dfs(d+1, last<<1, now<<1|1);
        dfs(d+1, last<<1|1, now<<1);
    }
    if  ( d+2 <= m)
    {
        dfs(d+2, last<<2|3, now<<2|3);
    }
}
int main ()
{
    while ( scanf("%d%d", &n, &m), n&&m )
    {
        if ( m*n%2 )
        {
            printf("0\n");
            continue;
        }
        if ( n > m )
        {
            int t= m;
            m= n;
            n= t;
        }
        memset( a, 0, sizeof(a) );
        init(0,0);
        for ( int i = 2; i <= n; i++ )
        {
            t=(i+1)%2;
            dfs(0, 0, 0);
            memset( a[(t+1)%2], 0, sizeof(a[0]) );
        }
        printf("%lld\n", a[(n+1)%2][(1<<m)-1]);
    }
    return 0;
}

purplest 2011-08-05 23:23 发表评论

poj 1163 The Triangle

purplest — Fri, 05 Aug 2011 15:04:00 GMT

自底向上贪心即可，其实就是dp的思想，用下面一层来更新上面一层

#include <stdio.h>

int n;
int num[100][100];

int max(int a, int b)
{
    return a>b?a:b;
}

int main()
{
    scanf("%d", &n);
    int i, j;
    for ( i = 0; i < n; i++ )
        for ( j = 0; j <= i; j++ )
            scanf("%d", num[i]+j);
    for ( i = n-1; i > 0; i-- )
        for ( j = 0 ; j < i; j++)
            num[i-1][j]+=max(num[i][j], num[i][j+1]);
    printf("%d\n", num[0][0]);
    return 0;
}

purplest 2011-08-05 23:04 发表评论

Poj 1631 Bridging signals

purplest — Sun, 31 Jul 2011 11:51:00 GMT

果的LIS，直接贴代码

#include <stdio.h>

int a[40000], b[40000], n, i, j, sum;

void LIS()
{
    int left= 0, right= sum-1, mid;

    if(0 == i)
    {
        b[0]=a[i];
    }
    else
    {
        while(left <= right)
        {
            mid= (left + right)>>1;
            if(b[mid] > a[i])
            {
                right= mid-1;
            }
            else
            {
                left= mid+1;
            }
        }
        b[left]= a[i];
        if(left >= sum)
        {
            sum++;
        }
    }
}

int main ()
{
    int m, j;
    scanf("%d", &m);
    for(j= 0; j < m; j++)
    {
        scanf("%d", &n);
        sum= 1;
        for(i= 0; i < n; i++)
        {
            scanf("%d", a+i);
            LIS();
        }
        printf("%d\n", sum);
    }
    return 0;
}

purplest 2011-07-31 19:51 发表评论