UVA - 10132 File Fragmentation（贪心）

最新推荐文章于 2018-11-23 18:06:27 发布

原创最新推荐文章于 2018-11-23 18:06:27 发布 · 944 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#uva #10132 #File Fragmentation

贪心专栏收录该内容

36 篇文章

订阅专栏

本文介绍了一个有趣的文件碎片重组问题及其实现算法。该算法通过贪心策略，将不同大小的文件碎片重新组合成完整的文件。文章详细解释了如何对文件碎片进行排序、匹配并验证其正确性的过程。

Question 2: File Fragmentation

The Problem

Your friend, a biochemistry major, tripped while carrying a tray of computer files through the lab. All of the files fell to the ground and broke. Your friend picked up all the file fragments and called you to ask for help putting them back together again.

Fortunately, all of the files on the tray were identical, all of them broke into exactly two fragments, and all of the file fragments were found. Unfortunately, the files didn't all break in the same place, and the fragments were completely mixed up by their fall to the floor.

You've translated the original binary fragments into strings of ASCII 1's and 0's, and you're planning to write a program to determine the bit pattern the files contained.

Input

The input begins with a single positive integer on a line by itself indicating the number of the cases following, each of them as described below. This line is followed by a blank line, and there is also a blank line between two consecutive inputs.

Input will consist of a sequence of ``file fragments'', one per line, terminated by the end-of-file marker. Each fragment consists of a string of ASCII 1's and 0's.

Output

For each test case, the output must follow the description below. The outputs of two consecutive cases will be separated by a blank line.

Output is a single line of ASCII 1's and 0's giving the bit pattern of the original files. If there are 2N fragments in the input, it should be possible to concatenate these fragments together in pairs to make N copies of the output string. If there is no unique solution, any of the possible solutions may be output.

Your friend is certain that there were no more than 144 files on the tray, and that the files were all less than 256 bytes in size.

Sample Input

Sample Output

01110111

题目大意：
你的朋友端着一个盘子，上面有N份相同的文件，但是不小心盘子摔倒地上了，每个文件都摔成两份。现在用01组成的字符串来表示原来的文件和碎片，现在输入所有的碎片，根据这些碎片求出原文件。

解析：贪心题，首先按照字符串的长度进行升序排序，
原字符串 = 最短的字符串 + 最长的字符串。
最多有8个字符串
因为最长的字符串和最短的字符串，都是至多两个。
让后最短的字符串和最长的字符串，还可以前后排列。
所以最多8种可能。

然后判断这些字符串，如果所有的字符串是该字符串的子字符串，就输出该字符串。

#include <string>
#include <iostream>
#include <algorithm>
using namespace std;

int cnt;
string file[150];
int maxlen,minlen;
bool cmp(string a,string b) {
	return a.size() < b.size();
}
bool judge(string str) {
	for(int i = 0; i < cnt; i++) {
		if(str.find(file[i]) == string::npos) {
			return false;
		}
	}
	return true;
}
void solve() {
	string target;
	for(int i = 0; file[i].size() == minlen; i++) {
		for(int j = cnt-1; file[j].size() == maxlen; j--) {
			for(int dir = 0; dir < 2; dir++) {
				switch(dir) {
					case 0:
						target = file[i] + file[j];
						break;
					case 1:
						target = file[j] + file[i];
						break;
				}
				if(judge(target)) {
					cout << target << endl;
					return ;
				}
			}
		}
	}
}
int main() {
	int t;
	cin >> t;
	cin.get();cin.get();
	while(t--) {
		for(cnt = 0;; cnt++) {
			getline(cin,file[cnt]);
			if(file[cnt] == "") {
				break;
			}
		}
		sort(file,file+cnt,cmp);
		maxlen = file[cnt-1].size();
		minlen = file[0].size();
		solve();
		if(t) {
			cout << endl;
		}
	}
	return 0;
}