2016程设期末伪题解

期末发挥实在是太差了-_-#
比2015年少了好多送分题，整体难度显得很大，但是考完之后静下来做又觉得并不是很难orz

---

1. 篮球联赛：暴力枚举（我用的 dfs 来枚举）

2. 夺宝探险：暴力 dfs

3. 寻找边缘：从边缘暴力 dfs

4. 猴子摘桃：可以直接用两个指针指向区间端点做到 O(n)

5. 分形盒：直接递归

6. 42点：暴力 dfs 遍历所有结果

以上几题就不放代码了

7. 上机：dp
题意：有 n 个座位排成一排（1<=n<=10000），给定坐到每个座位上两边有0个、1个和2个人时可获得的价值（左端左边和右端右边视为没有人），求 n 个同学全部上座后可获得的最大价值。
题解：考虑动态规划的一般套路，当新加进来一个位置 i 的时候，用 dp[i][0] 表示位置 i 右边没人时的最大值，dp[i][1] 表示右边有人时的最大值，考虑座位 i 上的人和座位 i-1 上的人谁先坐下，那么就有dp方程：
dp[i][0] = max(dp[i-1][0] + v[i][1], dp[i-1][1] + v[i][0]);
dp[i][1] = max(dp[i-1][0] + v[i][2], dp[i-1][1] + v[i][1]);
其中 v[i][j] 是坐在位置 i 上两边有 j 个人时的价值，时间复杂度为 O(n)。

#include 
#define MAX(a,b) ((a)>(b)?(a):(b))

int main()
{
    int n, v[10005][3], dp[10005][2];
    scanf("%d", &n);
    for (int j = 0; j <= 2; ++j)
        for (int i = 1; i <= n; ++i)
            scanf("%d", &v[i][j]);
    dp[1][0] = v[1][0]; dp[1][1] = v[1][1];
    for (int i = 2; i <= n; ++i)
    {
        dp[i][0] = MAX(dp[i - 1][0] + v[i][1], dp[i - 1][1] + v[i][0]);
        dp[i][1] = MAX(dp[i - 1][0] + v[i][2], dp[i - 1][1] + v[i][1]);
    }
    printf("%d", dp[n][0]);
    return 0;
}

8. 迷宫入口：较难的 dfs
题意：给定大正方形的边长和若干个小正方形的边长，问能否用这些小正方形恰好不重叠地拼成大正方形。
题解：直接考虑搜索，将小正方形从下往上从左往右摆，所以每次挑最低且最左端的位置放，放的时候优先考虑较大的（因为小的更灵活），关键在于如何记录放上去后的状态变化，直接利用二维数组标记会超时，考虑将大正方形分成列，用 col[i] 表示第 i 列有多少个格子被小正方形盖住，标记的复杂度直接降了一维。

#include 
#include 
using namespace std;

int ok, num[20], col[50];

void dfs(int lev, int n, int S)
{
    if (lev == n) {ok = 1; return;}
    int nowcol, tmp = 50;
    for (int i = 0; i < S; ++i)
        if (col[i] < tmp)
            {tmp = col[i]; nowcol = i;}        // 找到最低的且最左端的位置
    for (int nowS = 10; nowS > 0; --nowS)      // 从大到小枚举当前位置放的正方形边长
        if (num[nowS] && nowcol + nowS - 1 < S && col[nowcol] + nowS <= S)
        {                                      // 若有这种边长的小正方形且放上去不会越界
            int check = 1;
            for (int j = nowcol; j < nowcol + nowS; ++j)     // 检查能否放在当前位置
                check = check && (col[j] == col[nowcol]);
            if (check)
            {
                for (int j = nowcol; j < nowcol + nowS; ++j) // 更新相关列的状态
                    col[j] += nowS;
                num[nowS]--;                                 // 更新小正方形数量
                dfs(lev + 1, n, S); if (ok) return;
                for (int j = nowcol; j < nowcol + nowS; ++j) // 回溯
                    col[j] -= nowS;
                num[nowS]++;
            }
        }
}

int main()
{
    int t; cin >> t;
    while (t--)
    {
        int S, n, x, area = 0;
        cin >> S >> n;
        memset(num, 0, sizeof(num));
        memset(col, 0, sizeof(col));
        for (int i = 0; i < n; ++i)
        {
            cin >> x; num[x]++;
            area += x * x;
        }
        ok = 0;
        if (area == S * S) dfs(0, n, S);
        cout << (ok ? "YES" : "NO") << endl;
    }
    return 0;
}

9. 变换的迷宫：bfs 变形
题意：王子救公主，当时间恰能被 k 整除时墙会消失（2<=k<=10），求最短救出时间。
题解：bfs 的时候将时间模 k 的余数作为访问数组的第三维即可。

#include 
#include 
using namespace std;

int dx[] = {1,0,-1,0}, dy[] = {0,1,0,-1};

struct node{
    int x, y, time;
    node(int x_, int y_, int t_):x(x_),y(y_),time(t_){}
};

int main()
{
    int t; cin >> t;
    while (t--)
    {
        int r, c, k, sr, sc;
        cin >> r >> c >> k;
        char m[105][105], vis[105][195][15] = {0};  // 第三维是时间模k的余数
        for (int i = 0; i < r; ++i)
            for (int j = 0; j < c; ++j)
            {
                cin >> m[i][j];
                if (m[i][j] == 'S') {sr = i; sc = j;}
            }
        queue q;
        q.push(node(sr, sc, 0));
        vis[sr][sc][0] = 1;
        while (!q.empty())
        {
            node now = q.front();
            if (m[now.x][now.y] == 'E') break; q.pop();
            for (int i = 0; i < 4; ++i)
            {
                int newx = now.x + dx[i], newy = now.y + dy[i];
                if (newx >= 0 && newx < r && newy >= 0 && newy < c)
                    if (!vis[newx][newy][(now.time + 1) % k])
                        if ((m[newx][newy] != '#') || (m[newx][newy] == '#' && (now.time + 1) % k == 0))
                        {
                            vis[newx][newy][(now.time + 1) % k] = 1;
                            q.push(node(newx, newy, now.time + 1));
                        }
            }
        }
        if (!q.empty()) cout << q.front().time << endl;
        else cout << "Oop!" << endl;
    }
    return 0;
}

10. 游览规划：枚举+二维混合背包
题意：已知游乐场的门票费用和每个游乐项目所花费的时间、现金、次数限制（一次/无限次）以及可获得的欢乐值，求给定现金下可获得的最大欢乐值。
题解：枚举游玩天数，除掉门票钱之后对项目进行二维费用的混合背包（01/完全）。

#include 
#include 
#include 
#define MAX(a,b) ((a)>(b)?(a):(b))
using namespace std;

int dp[1005][2405] = {0};

void ZeroOnePack(int c, int t, int v, int totT, int totC)
{
    for (int i = totC; i >= c; --i)
        for (int j = totT; j >= t; --j)
            dp[i][j] = MAX(dp[i][j], dp[i - c][j - t] + v);
}

void CompletePack(int c, int t, int v, int totT, int totC)
{
    for (int i = c; i <= totC; ++i)
        for (int j = t; j <= totT; ++j)
            dp[i][j] = MAX(dp[i][j], dp[i - c][j - t] + v);
}

int main()
{
    int totDays, n, totMoney, ans = 0;
    int v[105], c[105], t[105], f[105];            // 欢乐值、现金、时间和次数限制
    string s;
    cin >> totDays >> n >> totMoney;
    for (int i = 0; i < n; ++i)
    {
        cin >> v[i] >> c[i] >> t[i] >> s;
        f[i] = (s[0] == 'u');
    }
    for (int day = 1; day <= totDays; ++day)       // 枚举天数
    {
        int totTime = day * 24;
        int totCost = totMoney - 200 * (day / 3);  // 扣掉门票钱
        if (day % 3 == 1) totCost -= 100;
        if (day % 3 == 2) totCost -= 150;
        if (totCost < 0) break;                    // 没钱就别玩了
        memset(dp, 0, sizeof(dp));
        for (int i = 0; i < n; ++i)                // 二维混合背包
            if (f[i]) CompletePack(c[i], t[i], v[i], totTime, totCost);
            else ZeroOnePack(c[i], t[i], v[i], totTime, totCost);
        ans = MAX(ans, dp[totCost][totTime]);
    }
    cout << ans << endl;
}

11. 张三丰的传人：搜索
题意：给定正整数S（1<=S<65536），求方程组
∑ni=1ai=S
∑ni=11ai=1
的一组正整数解（n 未知）。
题解：按递增顺序对解进行 dfs，连剪枝都不需要就直接过了-_-#

#include 
#include 
#include 
using namespace std;

int cnt, ok, ans[200];

// leftD为剩下整数的倒数和，leftS为剩下的整数和，last为上一个整数
void dfs(double leftD, int last, int leftS)
{
    if (fabs(leftD) < 1e-6 && leftS == 0) {ok = 1; return;}
    for (; last <= leftS; ++last)    // 枚举当前整数
    {
        if (leftD < 1.0/last - 1e-6) continue;
        ans[cnt++] = last;
        dfs(leftD - 1.0/last, last, leftS - last);
        if (!ok) --cnt; else break;  // 回溯
    }
}

int main()
{
    int t; cin >> t;
    while (t--)
    {
        int s; cin >> s; cnt = ok = 0;
        memset(ans, 0, sizeof(ans));
        dfs(1, 1, s);
        if (!cnt) cout << -1 << endl;
        else
        {
            cout << cnt;
            for (int i = 0; i < cnt; ++i) cout << ' ' << ans[i];
            cout << endl;
        }
    }
    return 0;
}