令 $A$ 是所有丑数构成的集合，容易想到，一个丑数是由小于该丑数的一个丑数乘以一个数 $S_i(1 \le i \le K)$ 得来的。

所以，对于一个丑数 $A_i$，枚举 集合 $S$ 和 集合 $A$ （也可以二分，不过速度本来就够快了），找到两个数 $S_i(1 \le i \le K)$ 和 $A_j(1 \le j \le i-1)$，使得 $S_i \cdot A_j > A_{i-1}$，对所有大于 $A_{i-1}$ 的数 $S_i(1 \le i \le K) \cdot A_j(1 \le j \le i-1)$，找到一个最小的数，赋值于 $A_i$。

即 $A_i \gets \min(S_i \cdot A_j)$，其中,$1 \le i \le K,1 \le j \le i-1$

最后，第 $N$ 个丑数就是 $A_N$

include<iostream>

#include<cstdio>

#include<algorithm>

#include<string.h>

using namespace std;;

int main()

{

   freopen("last_SYF.in","r",stdin);

   freopen("last_SYF.out","w",stdout); int n,m;cin>>n>>m; int c=__gcd(n,m);cout<<n/c<<"/"<<m/c; return 0;

}

这一题一开始我是用dfs选数，但是调试起来太麻烦了，于是换了一个思路，每次选出来 $n-1$ 个符号，最后check一下。

check 函数的策略是每遇到一个不为 空格 的字符就把当前的数 $now$ 加进变量 $x$ 中，然后 $now$ 初始化成当前字符的下一个数字（也就是 $i + 2$），接着把这个字符用 $sig$ 存起来作为下一个数的符号，如果遇到的字符是 空格 就把 $now$ 进一位加上 空格 后面的数，最后如果 $x$ 的值为 $0$，那么就符合要求。因为我的 $chosen$ 数组是从 $0$ 开始的，而 $1$ 一开始就加进了 $now$ 中，所以 "字符后面的那个数字" 对应的下标就是 $i + 2$。这个下标的问题花了我半天时间调试。

答案的输出的话其实没有那么麻烦，只需要把答案的字符串存起来排一下序就可以了，因为 std::string 本来就可以比较字典序的大小

总共只有八种情况：

1. 不按

2. 四个按钮分别按

3. 按1+4， 2+4 或 3+4

容易发现，前三个按钮任意两个同时按等价于按另外的第三个按钮，三个都按相当于没按

因此，只需要特判 $C \le 2$ 的情况就行了，其中 $C = 2$ 的情况比较特殊，因为第四个按钮不能被两个按钮转化而成

而对于 $C > 2$ 的情况，因为总有两个按钮可以转化成另外一个按钮，最后还是会回到这八种情况，所以枚举所有情况，判断与情况符合不符合就可以了

（其实就是打表）

题目数据规模不大，可选方法很多，考虑贪心。

本文中，称第 $i$ 行/列 的要求士兵数量为：第 $i$ 行/列 的名额。

很显然，对于第 $i$ 行第 $j$ 列的士兵，如果它可以放，并且能一次性占掉第 $i$ 行和第 $j$ 列的两个名额，称这样的士兵为 ”好士兵“。

根据贪心思路，我们当然希望“好士兵”的个数尽量的多，那么剩下的未被占掉的名额自然只能由一次性只占一个名额的士兵占掉。

那么：怎样让“好士兵”最多呢？

由题目可知，第 $i$ 行/列 的“好士兵”个数不能超过该 行/列 的名额总数。

这一点和网络流的容量限制很像，联想到网络流，进行建模：

设第 $i$ 行名额数为 $A_i$，对应点 $C_i$，第 $j$ 列名额数为 $B_j$，对应点 $D_j$。

分别建立两个顶点：起点 $S$，终点 $T$。

$S$ 向每个 $C_i$ 连一条容量为 $A_i$ 的边，每个 $D_j$ 向 $T$ 连一条容量为 $B_j$ 的边。

如果 $(i,j)$ 合法，由 $C_i$ 向 $D_j$ 引一条容量为 $1$ 的边。

这样，$S \to C_i \to D_j \to T$ 的一条路径就代表了 $(i,j)$ 上放置一名“好士兵”。

该图的最大流对应的即是最多的可放置的“好士兵”的个数，设为 $F$ ，则答案为

$\sum\limits_{i=1}^n A_i + \sum\limits_{j=1}^m B_j - F$

参考代码：

#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
using namespace std;
int n,m,k;
const int maxn = 10005;
const int maxm = 1000005;
int L[maxn],R[maxn],sum1[maxn],sum2[maxn],tot;
bool legit[maxn][maxn];
int head[maxm],ver[maxm << 1],nxt[maxm << 1],cap[maxm << 1],cur[maxm],cnt = -1;
void add(int u,int v,int t) {
	ver[++ cnt] = v;
	nxt[cnt] = head[u];
	head[u] = cnt;
	cap[cnt] = t;
	return ;
}
queue<int> q;
int level[maxn];
bool bfs(int s,int t) {
	memset(level , 0 , sizeof(level));
	q.push(s);
	level[s] = 1;
	while(!q.empty()) {
		int u = q.front();
		q.pop();
		for(int i = head[u];~ i;i = nxt[i]) {
			int v = ver[i];
			if(cap[i]&&!level[v]) {
				level[v] = level[u] + 1;
				q.push(v);
			}
		}
	}
	return level[t] > 0;
} 
int dfs(int x,int t,int maxflow) {
	if(x == t||!maxflow)return maxflow;
	int flow = 0,f;
	for(int& i = cur[x];~ i;i = nxt[i]) {
		int v = ver[i];
		if(level[v] == level[x] + 1&&(f = dfs(v , t , min(maxflow , cap[i])))) {
			if(!f) {
				level[v] = 0;
				break ;
			}
			flow += f;
			maxflow -= f;
			cap[i] -= f;
			cap[i ^ 1] += f;
			if(!maxflow)break ;
		}
	}
	return flow;
}
int Dinic(int s,int t) {
	int flow = 0;
	while(bfs(s , t)) {
		memcpy(cur , head , sizeof(head));
		flow += dfs(s , t , 0x3f3f3f3f);
	}
	return flow;
}
int main() {
	freopen("occupy.in","r",stdin);
	freopen("occupy.out","w",stdout);
	memset(head , -1 , sizeof(head));
	scanf("%d%d%d",&n,&m,&k);
	for(int i = 1;i <= n;++ i)
		for(int j = 1;j <= m;++ j)legit[i][j] = true;
	for(int i = 1;i <= n;++ i)scanf("%d",&L[i]),sum1[i] = m,tot += L[i];
	for(int i = 1;i <= m;++ i)scanf("%d",&R[i]),sum2[i] = n,tot += R[i];
	for(int i = 1;i <= k;++ i) {
		int x,y;
		scanf("%d%d",&x,&y);
		legit[x][y] = false;
		-- sum1[x];
		-- sum2[y];
	}
	bool flag = true;
	for(int i = 1;i <= n;++ i) {
		if(sum1[i] < L[i]) {
			flag = false;
			break ;
		} 
	}
	for(int i = 1;i <= m;++ i) {
		if(sum2[i] < R[i]) {
			flag = false;
			break ;
		}
	}
	if(!flag) {
		puts("JIONG!");
		return 0;
	}
	int S = n + m + 1,T = n + m + 2;
	for(int i = 1;i <= n;++ i) {
		add(S , i , L[i]);
		add(i , S , 0);
	}
	for(int i = 1;i <= m;++ i) {
		add(i + n , T , R[i]);
		add(T , i + n , 0);
	}
	for(int i = 1;i <= n;++ i) {
		for(int j = 1;j <= m;++ j) {
			if(legit[i][j]) {
				add(i , j + n , 1);
				add(j + n , i , 0);
			}
		}
	}
	printf("%d\n",tot - Dinic(S , T));
	return 0;
}

建图：源点->食物->牛->牛->饮料->汇点

边权都是1

跑最大流

然后就A了