USACO22DEC青铜组题解

T1：Cow College

总学费 $=$ 设置的单人学费 $\times$ 接受的奶牛数

一旦固定单人学费，就能确定接受的奶牛数

单人学费可以是哪些值？

$\{c_1, c_2, \cdots, c_n\}$ 其中之一作为学费门槛

暴力做法是先枚举单人学费是多少，再查看每个人的可接受学费是否大于等于单人学费，复杂度为 $O(n^2)$

可以通过对序列 $c$ 做降序排序来优化掉第二重循环

代码实现

n = int(input())
c = list(map(int, input().split()))
 
c.sort(reverse=True)
 
tot, ans = 0, 0
for i in range(n):
    if (i+1)*c[i] >= tot:
        tot = (i+1)*c[i]
        ans = c[i]
        
print(tot, ans)

T2：Feeding the Cows B

Saruman's Army

对每头 G，尽可能往右放 G 草地
对每头 H，允许（若越界）回过头往左找空地
可能带来的问题：

• 找不到
• 时间复杂度
• 整体最优解

1. 找不到---无解
   $k=0$，原地待命
   $k \geqslant 1$，种草稀疏
   

2. 时间复杂度
   $O(n)$
   从左回头找最多只会出现一次

3. 最优解

关键：G/H 草地不会互相抢占位置

代码实现

#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
 
using namespace std;
 
void solve() {
    int n, k;
    cin >> n >> k;
    string s;
    cin >> s;
    int cnt = 0;
    string ans = string(n, '.');
    // G
    rep(i, n) {
        if (s[i] == 'H') continue;
        int pos = min(i+k, n-1);
        ans[pos] = 'G';
        ++cnt;
        i = pos+k;
    }
    // H
    rep(i, n) {
        if (s[i] == 'G') continue;
        int pos = min(i+k, n-1);
        while (ans[pos] != '.') --pos;
        ans[pos] = 'H';
        ++cnt;
        i = pos+k;
    }
    cout << cnt << '\n' << ans << '\n';
}
 
int main() {
    int t;
    cin >> t;
    
    while (t--) solve();
    
    return 0;
}

T3：Reverse Engineering

程序分为有条件返回和无条件返回

有条件返回形如

if (b[i] == x)
    return y;

$x, y \in \{0, 1\}$

标准化（normalize)，对于可能性很多的复杂性事物，我们可以人为地制定一些规则使其有统一格式

1. 每一变量只判断一次
2. 程序一定可以写成 $n+1$ 行

算法：

1. 寻找一列 $i$，枚举 $x, y \in \{0, 1\}$，判断能否有 if (b[i] == x) return y;
2. 如果找到，则筛去 $b_i=x$ 的行，并筛去列 $i$
   如果找不到，判断：若所有输入都返回，则输出 OK，否则矛盾，输出 LTE
3. 回到步骤 $1$，总共 $n$ 次
4. 最后判断能否无条件返回 $0/1$

总时间复杂度为：$O(n^2m)$

代码实现

#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
 
using namespace std;
 
bool vr[105], vc[105];
 
void solve() {
    memset(vr, false, sizeof vr);
    memset(vc, false, sizeof vc);
    
    int n, m;
    cin >> n >> m;
    vector<string> s(m);
    vector<int> val(m);
    rep(i, m) cin >> s[i] >> val[i];
    
    auto Return = [&](int id, int x, int y) {
        rep(i, m) {
            if (vr[i]) continue;
            if (s[i][id]-'0' == x) {
                if (val[i] != y) return false;
            }
        }
        return true;
    };
    auto Return2 = [&](int y) {
        rep(i, m) {
            if (vr[i]) continue;
            if (val[i] != y) return false;
        }
        return true;
    };
    auto ok = [&]{
        rep(i, n) {
            bool found = false;
            // 判断是否有 if (b[j] == x) return y; 这一程序语句是否成立 -> Return(j, x, y)
            rep(j, n) if (!found) {
                rep(x, 2) if (!found) {
                    rep(y, 2) if (!found) {
                        if (!vc[j] and Return(j, x, y)) {
                            found = vc[j] = true;
                            rep(k, m) {
                                // 这一输入不能因为之前的程序语句就结束了，因此这一行要未被筛选过
                                if (!vr[k] and s[k][j]-'0' == x) {
                                    vr[k] = true;
                                }
                            }
                        }
                    }
                }
            }
            if (!found) break;
        }
        return Return2(0) or Return2(1);
    }();
    
    if (ok) puts("OK");
    else puts("LIE");
}
 
int main() {
    int t;
    cin >> t;
    
    while (t--) solve();
    
    return 0;
}