hdu4545--暴力/水dp--LCS/LIS真的是个好东西

数据不大 可以暴力做..

不想提这该死的暴力了  晓爷 你出来 保证不打死你！

这题 也可以用Lcs来做 相比于以往的最裸的lcs 就是多了个 hash配对

只要多添加个条件就可以了

既然是Lcs 那么就可以用 滚动数组来优化下

因为dp[i][j] 这一状态 只与dp[i-1][j] dp[i-1][j-1] dp[i][j-1]这3个状态有关 那么即只和这一行和前一行有关系 我们可以只开一个2维数组 第一维的大小为2就足够了 存储当前行与上一行的值 以后就不断转移 覆盖

还可以更节约内存  只通过2个中间变量 来传递状态的值

var----dp[i-1][j-1]      dp[j-1] ----- dp[i][j-1]     dp[j] ----- dp[i-1][j]

暴力的代码 不贴了 搞的心好累.

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;

const int size = 1010;
char ss[size];
char tt[size];
int dp[size];
bool hash[30][30];

int main()
{
    int t , m , len1 , len2 , var , temp;
    char x , y;
    cin >> t;
    for( int k = 1 ; k<=t ; k++ )
    {
        cin >> (ss+1) >> (tt+1);
        cin >> m;
        memset( dp , 0 , sizeof(dp) );
        memset( hash , false , sizeof(hash) );
        len1 = strlen(ss+1);
        len2 = strlen(tt+1);
        while( m-- )
        {
            cin >> x >> y;
            hash[x-'a'][y-'a'] = true;
        }
        for( int i = 1 ; i<=len1 ; i++ )
        {
            var = 0;
            for( int j = 1 ; j<=len2 ; j++ )
            {
                temp = dp[j];
                if( ss[i] == tt[j] || hash[ tt[j]-'a' ][ ss[i]-'a' ] )
                {
                    dp[j] = var + 1;
                }
                else
                {
                    dp[j] = max( dp[j-1] , dp[j] );
                }
                var = temp;
            }
        }
        cout << "Case #" << k << ": ";
        if( dp[len2] == len1 )
            cout << "happy" << endl;
        else
            cout << "unhappy" << endl;
    }
    return 0;
}

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;

const int size = 1010;
char ss[size];
char tt[size];
int dp[size][size];
bool hash[30][30];

int main()
{
    int t , m , len1 , len2;
    char x , y;
    cin >> t;
    for( int k = 1 ; k<=t ; k++ )
    {
        cin >> (ss+1) >> (tt+1);
        cin >> m;
        memset( dp , 0 , sizeof(dp) );
        memset( hash , false , sizeof(hash) );
        len1 = strlen(ss+1);
        len2 = strlen(tt+1);
        while( m-- )
        {
            cin >> x >> y;
            hash[x-'a'][y-'a'] = true;
        }
        for( int i = 1 ; i<=len1 ; i++ )
        {
            for( int j = 1 ; j<=len2 ; j++ )
            {
                if( ss[i] == tt[j] || hash[ tt[j]-'a' ][ ss[i]-'a' ] )
                {
                    dp[i][j] = dp[i-1][j-1] + 1;
                }
                else
                {
                    dp[i][j] = max( dp[i-1][j] , dp[i][j-1] );
                }
            }
        }
        cout << "Case #" << k << ": ";
        if( dp[len1][len2] == len1 )
            cout << "happy" << endl;
        else
            cout << "unhappy" << endl;
    }
    return 0;
}

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;

const int size = 1010;
char ss[size];
char tt[size];
int dp[2][size];
bool hash[30][30];

int main()
{
    int t , m , len1 , len2;
    char x , y;
    cin >> t;
    for( int k = 1 ; k<=t ; k++ )
    {
        cin >> (ss+1) >> (tt+1);
        cin >> m;
        memset( dp , 0 , sizeof(dp) );
        memset( hash , false , sizeof(hash) );
        len1 = strlen(ss+1);
        len2 = strlen(tt+1);
        while( m-- )
        {
            cin >> x >> y;
            hash[x-'a'][y-'a'] = true;
        }
        for( int i = 1 ; i<=len1 ; i++ )
        {
            for( int j = 1 ; j<=len2 ; j++ )
            {
                if( ss[i] == tt[j] || hash[ tt[j]-'a' ][ ss[i]-'a' ] )
                {
                    dp[i%2][j] = dp[(i-1)%2][j-1] + 1;
                }
                else
                {
                    dp[i%2][j] = max( dp[(i-1)%2][j] , dp[i%2][j-1] );
                }
            }
        }
        cout << "Case #" << k << ": ";
        if( dp[len1%2][len2] == len1 )
            cout << "happy" << endl;
        else
            cout << "unhappy" << endl;
    }
    return 0;
}

永远 最容易理解的 是 消耗最大的-

today:

　　我也曾经憧憬过 后来没结果

　　我也曾经做梦过 后来更寂寞

　　假装我很怀旧