PKU1692 Crossed Matchings

/*
Crossed Matchings
Time Limit: 1000MS        Memory Limit: 10000K
Total Submissions: 998        Accepted: 614

Description
There are two rows of positive integer numbers. We can draw one line segment between any two equal numbers, with values r, if one of them is located in the first row and the other one is located in the second row. We call this line segment an r-matching segment. The following figure shows a 3-matching and a 2-matching segment.

We want to find the maximum number of matching segments possible to draw for the given input, such that:
1. Each a-matching segment should cross exactly one b-matching segment, where a != b .
2. No two matching segments can be drawn from a number. For example, the following matchings are not allowed.

Write a program to compute the maximum number of matching segments for the input data. Note that this number is always even.

Input
The first line of the input is the number M, which is the number of test cases (1 <= M <= 10). Each test case has three lines. The first line contains N1 and N2, the number of integers on the first and the second row respectively. The next line contains N1 integers which are the numbers on the first row. The third line contains N2 integers which are the numbers on the second row. All numbers are positive integers less than 100.

Output
Output should have one separate line for each test case. The maximum number of matching segments for each test case should be written in one separate line.

Sample Input

3
6 6
1 3 1 3 1 3
3 1 3 1 3 1
4 4
1 1 3 3
1 1 3 3
12 11
1 2 3 3 2 4 1 5 1 3 5 10
3 1 2 3 2 4 12 1 5 5 3

Sample Output

6
0
8

Source
Tehran 1999*/

#include <iostream>
using namespace std;
int solution(int up[],int down[],int n1,int n2)
{
    int v[101][101] = {0};
    int i,j,m,n,mx;
    for(i = 1;i <= n1;i++)
    {
        for(j = 1;j <= n2;j++)
        {
            mx = 0;
            if(up[i] != down[j])
            {
                for(m = j - 1;m > 0;m--)
                {
                    if(up[i] == down[m])
                    {
                        for(n = i - 1;n > 0;n--)
                        {
                            if(up[n] == down[j])
                            {
                                if(n && m && mx < v[n - 1][m - 1] + 2)
                                {
                                    mx = v[n - 1][m - 1] + 2;
                                }
                               
                           
                            }
                        }
                    }
                }
            }
            if(mx < v[i - 1][j])
            {
                mx = v[i - 1][j];
            }
            if(mx < v[i][j - 1])
            {
                mx = v[i][j - 1];
            }
            if(mx < v[i - 1][j - 1])
            {
                mx = v[i - 1][j - 1];
            }
            v[i][j] = mx;

        }
    }
    return v[n1][n2];
}
int main(void)
{
    int N;
    cin>>N;
    int n1,n2;
    int up[101],down[101];
    while(N > 0)
    {
        N--;
        cin>>n1>>n2;
        for(int i = 1;i <= n1;i++)
        {
            cin>>up[i];
        }
        for(int j = 1;j <= n2;j++)
        {
            cin>>down[j];
        }
        cout<<solution(up,down,n1,n2)<<endl;
    }

    return 0;
}

 

 

动态规划好题。。。首先创建一个数组V［101］［101］用于存储状态，V［I］［J］表示当第一行I个第二行J个数字时最多的连线的条数（最开始留空V［0］［0］ ＝ 0，最开始从V［1］［1］开始，这样初状态的描述简单点）

本题的难点在于2个。。1个就是动态规划最重要的状态转换。。。设当前情况是V［I］［J］时。。这个时候分4种情况。。即是点i和点j都有线连出来，i和j都没有线连出来，i有线连出来而j没有，i没有线连出来而j有。。

这4种情况中比较后最大的那个就是V［I］［J］时最多可以有的线的条数。。

第2个难点就是对于以上4种情况。。。。我们必须看出每种情况其实都包含有一种共同的情况。。那就是点i和点j都有线连出来这种情况。。。。于是我们的方程是针对这种情况的。。从这2个点开始往前找线（mx = v[n - 1][m - 1] + 2）。。。得出最佳的MAX后再与其他三种情况比较后得出最大值。