SGU 205. Quantization Problem

205. Quantization Problem

time limit per test: 0.25 sec.
memory limit per test: 65536 KB
input: standard
output: standard

When entering some analog data into a computer, this information must be quantized. Quantization transforms each measured value x to some other value l(x) selected from the predefined set L of levels. Sometimes to reduce the influence of the levels set to the information, the group of levels sets Li is used. The number of levels sets is usually chosen to be the power of 2.

When using the number of levels sets, some additional information should be used to specify which set was used for each quantization. However, providing this information may be too expensive — the better solution would be to choose more levels and use one set. To avoid the specification of the quantization set, the following technique is used. Suppose that n values \(x_1, x_2, ..., x_n\) are to be quantized and the group of \(m=2^p\) levels sets \(Li, i=0, ..., m-1\); each of size \(s=2^q\) is used to quantize it. After quantization \(x_j\) is replaced with some number \(l_j = in L_{f(j)}\). Instead of sending \(l_j\), its ordinal number in \(L_{f(j)}\) is usually sent, let \(k_j\) be the ordinal number of \(l_j\) in \(L_{f(j)}\) (levels are numbered starting with 0). Take p least significant bits of \(k_j\) and say that the number \(k_j\ \&\ (2^p-1)\) is the number of the levels set that will be used for next quantization, that is \(f(j+1) = k_j\ \&\ (2^p-1)\).

Since the least significant bits of kj are usually distributed quite randomly, the sets used for quantization change often and weakly depend on values of quantized data, thus this technique provides the good way to perform the quantization.

Usually to perform the quantization the closest to the value level of the levels set is chosen. However, using the technique described, sometimes it pays off to choose not the optimal level, but some other one, the ordinal number of which has other least significant bits, thus choosing another levels set for next measure and providing better approximation of quantized values in the future. Let us call the deviation of quantization the value of \(\sum_{j=1}^{n}|xj - lj|\). Your task is given measures and levels sets to choose quantized value for each measure in such a way, that the deviation of quantization is minimal possible.

The first value is always quantized using set L0.

Input

The first line of the input file contains n (1 ≤ n ≤ 1000). The second line contains n integer numbers xi ranging from 1 to 106. The next line contains m and s \((1 ≤ m ≤ 128, m ≤ s ≤ 128)\). Next m lines contain s integer numbers each — levels of the quantization sets given in increasing order for each set, all levels satisfy \(1 ≤ level ≤ 10^6\).

Output

First output the minimal possible deviation of the quantization. Then output n integer numbers in range from 0 to s - 1. For each input value output the number of the level in the corresponding levels set \((k_j)\) used for this number to achieve the quantization required.

Sample test(s)

Input

3
8 8 19
2 4
5 10 15 20
3 7 13 17

Output

5
1 1 3

---

题意

给出一列长n的数列\(\{S_i\}\)和一个\(m\times s\)的矩阵\(A\)(\(m\le s\)且\(m,s\)都是2的整数次方)。求一列数\(\{K_i\}\)，使\(K_0=0\)，且 \(\sum_{i=1}^{n}{|A_{K_{i-1} \mod m, K_i}-S_i|}\)最小。

引用与修改自Amber——SGU 提示

---

看懂题了就是sb题了。

由于在阶段i时对答案产生影响的只有\(K_i\)和\(K_{i-1}\)的取值，显然可以DP做。不妨用f[i][j]表示考虑到第i个数字\(K_i\)取j时的最小值，转移是显然的：f[i][j]=min(f[i-1][k]+A[k%m][j]-S[i])，注意记录路径，然后没了。。就是题意难懂啊。

#include <bits/stdc++.h>
#define rep(_i, _j) for(int _i = 0; _i < _j; ++_i)
const int inf = 0x3f3f3f3f;
typedef long long LL;
typedef double DB;
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 1000 + 10;
const int maxm = 128 + 2;

int n, m, s, A[maxm][maxm], f[maxn][maxm], pre[maxn][maxm], S[maxn];

int main() {
#ifndef ONLINE_JUDGE
	freopen("205.in", "r", stdin); freopen("205.out", "w", stdout);
#endif

	scanf("%d", &n);
	for(int i = 1; i <= n; scanf("%d", &S[i]), ++i); // 大家不要学我这样写。。。
	scanf("%d%d", &m, &s);
	rep(i, m) rep(j, s) scanf("%d", &A[i][j]);
	memset(f, INF, sizeof f);
	f[0][0] = 0;
	for(int i = 1; i <= n; ++i) {
		for(int j = 0; j < s; ++j) {
			if(i == 1) {
				f[i][j] = min(f[i][j], f[i - 1][0] + abs(A[0][j] - S[i]));
				pre[i][j] = 0;
				continue;
			}
			for(int k = 0; k < s; ++k) {
				int tmp = f[i - 1][k] + abs(A[k % m][j] - S[i]);
				if(tmp < f[i][j]) {
					pre[i][j] = k;
					f[i][j] = tmp;
				}
			}
		}
	}
	int ans = INF, rec;
	for(int i = 0; i < s; ++i) {
		if(f[n][i] < ans) {
			ans = f[n][i];
			rec = i;
		}
	}
	printf("%d\n", ans);
	vector<int> res;
	int i = n;
	while(i != 0) {
		res.push_back(rec);
		rec = pre[i--][rec];
	}
	printf("%d", res[res.size() - 1]);
	for(int i = res.size() - 2; 0 <= i; --i) {
		printf(" %d", res[i]);
	}
	puts("");

	return 0;
}