27. 双塔问题

description

从前，有一个古老的帝国有两个形状不同的塔分别在不同的两个城市里。这两个塔是用圆形的砖一块一块建成的。这些圆形砖的高度是一样的，其半径都是整数。很明显，尽管这两个塔形状不同，但造塔所使用的圆形砖却有很多是相同的。

过了很多年，一个国王命令他的建筑师们移除两个塔的部分砖以便使它们的形状完全一样，同时使两个塔的高度尽可能的高，并且新塔的砖瓦的排列顺序必须与原来的一样。国王认为这样的两个塔象征着这两个城市之间的和谐和平等，于是命名它们为双胞胎塔。

现在，两千年以后，你可以来处理这样非常简单的问题：给你两个不同形状塔的描述，你只要算出能建成的新双塔的最多的砖瓦数。

输入

输入包括以下内容：第一行输入两个整数 N1 和 N2 (1 <= N1，N2 <= 100) 分别表示最初时两个塔的砖瓦数；第二行输入 N1 个正整数表示第一个塔砖瓦的半径（按从上到下的顺序排列）；下面的一行输入 N2 个整数表示第二个塔砖瓦的半径（按从上到下的顺序排列）。

当输入的 N1 和 N2 为 0 时结束。

输出

输出建成的新双塔的最多的砖瓦数。

	测试输入	期待的输出	时间限制	内存限制	额外进程
测试用例 1	以文本方式显示 7 6↵ 20 15 10 15 25 20 15↵ 15 25 10 20 15 20↵ 8 9↵ 10 20 20 10 20 10 20 10↵ 20 10 20 10 10 20 10 10 20↵ 0 0↵	以文本方式显示 Twin Towers #1↵ Number of Tiles : 4↵ Twin Towers #2↵ Number of Tiles : 6↵	1秒	1024KB	0

code

<回溯>

我最先想到的回溯的方法，其实就是穷举，遍历所有的可能，然后去掉不符合的（或者说取最大长度的）
代码：

#include <iostream>

using namespace std;

int n1, n2;
int hight = 0;
int* t1 = NULL;
int* t2 = NULL;

/**
 * flag:0:这块砖留着，1：这块砖拆掉
 * level1:塔1的层数，从上到下
 * level2:塔2的层数，从上到下
 * high:得到的新塔的高度
 * */
void dfs(int flag, int level1, int level2, int high)
{
    if(level1 == n1 || level2 == n2) {  //只要其中有一个塔已经没有砖了就是递归结束的条件

        hight = high > hight ? high : hight;
        return;
    }
    if(flag == 0) {  //这块砖不拆
        int i = 0;
        for(i = level2; i < n2; i++) {  //从level2开始匹配，前面的都被用掉了
            if(t2[i] == t1[level1])
                break;  //找到和塔1的这一个砖相同的，不一样的都不要
        }
        if(i >= n2)  //塔2中已经没有相同的砖,剪枝
            return;

        if(n2 - i + high <= hight)  //剩下的塔2的全部保留都不够高，剪枝
            return;

        dfs(0, level1 + 1, i + 1, high + 1);
        dfs(1, level1 + 1, i + 1, high + 1);
    }
    else {  //这块砖拆掉，直接进入下一块转
        dfs(0, level1 + 1, level2, high);
        dfs(1, level1 + 1, level2, high);
    }
}

int main()
{
    // freopen("file out.txt", "r", stdin);
    cin >> n1 >> n2;
    int count = 0;
    while(n1 && n2) {
        count++;
        t1 = new int[n1];
        t2 = new int[n2];
        for(int i = 0; i < n1; i++) {
            cin >> t1[i];
        }
        for(int i = 0; i < n2; i++) {
            cin >> t2[i];
        }
        hight = 0;  //初始化

        dfs(0, 0, 0, 0);  //不拆；塔1的第0层；塔2的第0层
        dfs(1, 0, 0, 0);  //拆；塔1的第0层；塔2的第0层

        cout << "Twin Towers #" << count << endl;
        cout << "Number of Tiles : " << hight << endl;

        cin >> n1 >> n2;

        delete[] t1;
        delete[] t2;
    }

    return 0;
}

很显然这个方法TLE了，只能想想其他的办法了

---

<动态规划 最长公共子序列>

这个题我们只需要输出最大的长度（高度）就行，降低了难度
代码：

#include <iostream>
using namespace std;

//这其实是一个建立二维数组表的过程
// 注意字符串的索引从0开始，打表从1开始有效,相差一个1
void LCSLength(int n1, int n2, int* t1, int* t2, int** c)
{
    int i, j;
    for(i = 0; i <= n1; i++) {
        c[i][0] = 0;
    }
    for(i = 1; i <= n2; i++) {
        c[0][i] = 0;
    }
    for(i = 1; i <= n1; i++) {
        for(j = 1; j <= n2; j++) {
            if(t1[i - 1] == t2[j - 1]) {
                c[i][j] = c[i - 1][j - 1] + 1;
            }
            else if(c[i - 1][j] >= c[i][j - 1]) {
                c[i][j] = c[i - 1][j];
            }
            else {
                c[i][j] = c[i][j - 1];
            }
        }
    }
}

int main()
{
    int n1, n2;  //两个塔各自的高度

    int* t1 = NULL;  //塔1
    int* t2 = NULL;  //塔2
    // freopen("file out.txt", "r", stdin);
    cin >> n1 >> n2;
    int count = 0;

    int** c;  // 记录数据的表格

    while(n1 && n2) {
        count++;
        t1 = new int[n1];
        t2 = new int[n2];
        c = new int*[n1 + 1];
        for(int i = 0; i <= n1; i++) {
            c[i] = new int[n2 + 1];
        }

        for(int i = 0; i < n1; i++) {
            cin >> t1[i];
        }
        for(int i = 0; i < n2; i++) {
            cin >> t2[i];
        }

        LCSLength(n1, n2, t1, t2, c);

        cout << "Twin Towers #" << count << endl;
        cout << "Number of Tiles : " << c[n1][n2] << endl;

        delete[] t1;
        delete[] t2;
        for(int i = 0; i <= n1; i++)
            delete[] c[i];
        delete[] c;
        cin >> n1 >> n2;
    }

    return 0;
}