「BSOJ2281」 教主的难题 - BFS+MST

题目描述

一个数x可以按以下规则生成数字：
1、将任意两位交换，若交换的数字为a和b，生成的代价为((a and b)+(a xor b))*2。

例如134可以生成431，因为431可以从134的个位（4）与百位（1）交换后得到，代价为((1 and 4)+(1 xor 4))*2=10。

2、将其中一位数删除，但是删除的数要满足大等于它左边的数，且小等于它右边的数，并且定义最高位左边的数为个位，个位右边的数为最高位。若删除的数字为a，它左边的数为b，它右边的数为c，则生成的代价为a+(b and c)+(b xor c)。

例如212，可以删除个位的数得到21，但是因为2>1，所以1是不能被删除的。特别地，若x为两位数，它能删除当且仅当x的两位数相同，若x为一位数，它是不能被删除的。

3、在两位数字之间，也可以是数字的前面或后面加入一位数，同样地，加入的数要满足大等于它左边的数，且小等于它右边的数，并且定义最高位左边的数为个位，个位右边的数为最高位。若加入的数字为a，它左边的数为b，它右边的数为c，则生成的代价为a+(b and c)+(b xor c)。

例如241，它可以在2与4之间加入一个3，生成2341，也可以在数的末尾加入一个1或者2，当然还有其它可以生成的数，但是不能在4和1之间加入数字。

你的任务是，S一开始为n个不同的给定数组成的集合，每次可以从S中取出一个数生成一个满足生成规则的数加入S中，并且取出的数仍然存在于S中。生成的数的位数不能大于S初始集合最大的数的位数。问在S元素最多的情况下，总代价最小是多少。

输入格式

输入的第1行为一个正整数n，为集合S初始元素个数。

第2行包含n个正整数a1,a2, …, an，数之间空格隔开，为S中初始元素。

输出格式

输出包括一个正整数，为最小代价。

样例输入

2
111 22

样例输出

12

样例解释

111删除1得到11，代价为2，11删除1得到1，代价为2，同样22删除和加入一个2得到2，222，代价均为4，总代价2+2+4+4=12。111无法生成1111因为111为一个3位数，而1111为一个4位数。

利用交换/添加规则无法让集合元素更多，所以最小代价为12。

数据规模与约定

对于20%的数据，有$a_i<100$；
对于40%的数据，有$a_i<1000$；
对于50%的数据，有$n=1$；
对于60%的数据，有$a_i<10000$；
对于100%的数据，有$a_i<100000,n\le 5$，保证的任何一位不包含0。

分析

这一题可以用BFS+MST解决，用BFS的同时用Prim统计答案。至于变化，写得让人心痛。本人调试了2个小时，最后竟然把$p、q$写反了…这件事告诉我们写代码时不要用相近的字母作为变量。

再说一句，本人写的代码用了vector与map，不会的同学可以去网上查阅。

代码

#include <iostream>
#include <cstdio>
#include <queue>
#include <cstring>
#include <cmath>
#include <map>
#include <vector>
#define inf 0x7fffffff/2
#define vti vector<int>
using namespace std;
struct node {
	vector<int> k;
	int cost;
	friend bool operator <(node a,node b) {
		return a.cost>b.cost;
	}
};
int n,lim,cnt,ans;
map<vti,bool> book;
priority_queue<node> q;
void change(vti p) {
	for (int i = 0;i < p.size();i++) {
		for (int j = i+1;j < p.size();j++) {
			swap(p[i],p[j]);
			if (!book[p])
			q.push((node){p,((p[i]&p[j])+(p[i]^p[j]))*2});
			swap(p[i],p[j]);
		}
	}
}
void add(vti p) {
	if (p.size()>=lim) return;
	for (int i = 0;i < p.size();i++) {
		for (int j = 1;j <= 9;j++) {
			vti v=p;
			if (i==0) {
				if (p[p.size()-1]<=j&&j<=p[i]) {
					int cost=j+(p[p.size()-1]&p[i])+(p[p.size()-1]^p[i]);
					v.insert(v.begin(),j);
					if (!book[v])
					q.push((node){v,cost});
				}
			} else {
				if (p[i-1]<=j&&j<=p[i]) {
					int cost=j+(p[i-1]&p[i])+(p[i-1]^p[i]);
					v.insert(v.begin()+i,j);
					if (!book[v])
					q.push((node){v,cost});
				}
			}
		}
	}
	for (int j = 1;j <= 9;j++) {
		vti v=p;
		if (p[p.size()-1]<=j&&j<=p[0]) {
			int cost=j+(p[p.size()-1]&p[0])+(p[p.size()-1]^p[0]);
			v.push_back(j);
			if (!book[v])
			q.push((node){v,cost});
		}
	}
}
void delt(vti p) {
	if (p.size()==1) return;
	if (p.size()==2&&p[0]!=p[1]) return;
	if (p.size()==2&&p[0]==p[1]) {
		vti t;
		int cost=2*p[0];
		t.push_back(p[0]);
		if (!book[t])
		q.push((node){t,cost});
		return;
	}
	for (int i = 0;i < p.size();i++) {
		vti v=p;
		if (i==0) {
			if (p[p.size()-1]<=p[0]&&p[0]<=p[1]) {
				int cost=p[0]+(p[p.size()-1]&p[1])+(p[p.size()-1]^p[1]);
				v.erase(v.begin());
				if (!book[v])
				q.push((node){v,cost});
			}
		} else if (i==p.size()-1) {
			if (p[i-1]<=p[i]&&p[i]<=p[0]) {
				int cost=p[i]+(p[i-1]&p[0])+(p[i-1]^p[0]);
				v.erase(v.end()-1);
				if (!book[v])
				q.push((node){v,cost});
			}
		} else {
			if (p[i-1]<=p[i]&&p[i]<=p[i+1]) {
				int cost=p[i]+(p[i-1]&p[i+1])+(p[i-1]^p[i+1]);
				v.erase(v.begin()+i);
				if (!book[v])
				q.push((node){v,cost});
			}
		}
	}
}
void bfs() {
	while (!q.empty()) {
		node h=q.top();
		q.pop();
		if (h.k.size()>lim) continue;
		if (book[h.k]) continue;
		book[h.k]=1;
		ans+=h.cost;
		change(h.k);
		add(h.k);
		delt(h.k);
	}
}
int main() {
	scanf("%d",&n);
	vti t;
	for (int i = 1;i <= n;i++) {
		t.clear();
		char ch=getchar();
		while (ch<'0'||ch>'9') ch=getchar();
		while (ch>='0'&&ch<='9') {
			t.push_back(ch-'0');
			ch=getchar();
		}
		q.push((node){t,0});
		lim=max(lim,(int)t.size());
	}
	bfs();
	printf("%d",ans);
	return 0;
}