DS逆散列问题

题目描述

给定长度为 N 的散列表，处理整数最常用的散列映射是 H(x)=x%N。如果我们决定用线性探测解决冲突问题，则给定一个顺序输入的整数序列后，我们可以很容易得到这些整数在散列表中的分布。例如我们将 1、2、3 顺序插入长度为 3 的散列表HT[]后，将得到HT[0]=3，HT[1]=1，HT[2]=2的结果。

但是现在要求解决的是“逆散列问题”，即给定整数在散列表中的分布，问这些整数是按什么顺序插入的？

输入

输入的第一行是正整数 N（≤1000），为散列表的长度。第二行给出了 N 个整数，其间用空格分隔，每个整数在序列中的位置（第一个数位置为0）即是其在散列表中的位置，其中负数表示表中该位置没有元素。题目保证表中的非负整数是各不相同的。

输出

按照插入的顺序输出这些整数，其间用空格分隔，行首尾不能有多余的空格。注意：对应同一种分布结果，插入顺序有可能不唯一。例如按照顺序 3、2、1 插入长度为 3 的散列表，我们会得到跟 1、2、3 顺序插入一样的结果。在此规定：当前的插入有多种选择时，必须选择最小的数字，这样就保证了最终输出结果的唯一性。

输入样例1

11
33 1 13 12 34 38 27 22 32 -1 21

输出样例1

1 13 12 21 33 34 38 27 22 32

NOTICE：

大致思路是：整个题有个基本原则，即若插入有多种选择，优先小的先插入；因此我们先将输入序列进行升序排序，然后挨个检查是否满足插入条件，满足则输出，不满足则放进一个待插入的数组；每成功输出一个，就要回过头来检查待插入数组中的元素是否可以插入；挨个检查完后，若待插入数组中还有剩余元素，则需要继续将它们插入；

插入条件：该数取余得数正好对应其在输入序列中的顺序；

other中插入条件：从下标为该数取余得数开始，到该数在输入序列中的位置之前，都已经有元素插入；

代码是修修补补才ac的，挺烂的。。。

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

int index(int* a, int obj)//返回对应下标
{
	for (int i = 0; ; i++)
	{
		if (a[i] == obj)
			return i;
	}
}

int judge(int* a, int n)//判断other数组中是否还有元素
{
	for (int i = 0; i < n; i++)
	{
		if (a[i] != -1)
			return 1;
	}
	return 0;
}

int main()
{
	int n;
	cin >> n;
	//输入
	int* in = new int[n];
	for (int i = 0; i < n; i++)
		cin >> in[i];
	//输入的升序排序
	int* up = new int[n];
	for (int i = 0; i < n; i++)
		up[i] = in[i];
	sort(up, up + n);
	//不满足插入条件的元素
	int* other = new int[n];
	int count = 0;
	//是否已插入的标志
	int* flag = new int[n];
	for (int i = 0; i < n; i++)
		flag[i] = 0;


	for (int i = 0; i < n; i++)
	{
		if (up[i] >= 0)//元素为负数说明没有元素
		{
			if (count != 0)//每次都要回头检查other中元素是否可以插入
			{
				for (int j = 0; j < count; j++)
				{
					if (other[j] != -1)
					{
						int tag = 0;
						for (int k = other[j] % n; k != index(in, other[j]); k = (k + 1) % 11)
						{
							if (flag[k] == 0)
							{
								tag = 1;
								break;
							}
						}
						if (tag == 0)
						{
							cout << other[j] << " ";
							flag[index(in, other[j])] = 1;
							other[j] = -1;
						}
					}

				}
			}

			//判断是否满足插入条件
			if (up[i] % n == index(in, up[i]))
			{
				cout << up[i] << " ";
				flag[index(in, up[i])] = 1;
			}
			else
				other[count++] = up[i];
		}
	}

	while (judge(other, count))//插入other中剩余元素
	{
		for (int i = 0; i < count; i++)
		{
			if (other[i] != -1)
			{
				int tag = 0;
				for (int k = other[i] % n; k < index(in, other[i]); k++)
				{
					if (flag[k] == 0)
					{
						tag = 1;
						break;
					}
				}
				if (tag == 0)
				{
					cout << other[i] << " ";
					flag[index(in, other[i])] = 1;
					other[i] = -1;
					break;
				}
			}
		}
	}

	return 0;
}