[POJ1772] Substract
问题描述
We are given a sequence of N positive integers a = [a1, a2, ..., aN] on which we can perform contraction operations.
One contraction operation consists of replacing adjacent elements ai and ai+1 by their difference ai-ai+1. For a sequence of N integers, we can perform exactly N-1 different contraction operations, each of which results in a new (N-1) element sequence.Precisely, let con(a,i) denote the (N-1) element sequence obtained from [a1, a2, ..., aN] by replacing the elements ai and ai+1 by a single integer ai-ai+1:
con(a,i) = [a1, ..., ai-1, ai-ai+1, ai+2, ..., aN]
Applying N-1 contractions to any given sequence of N integers obviously yields a single integer.
For example, applying contractions 2, 3, 2 and 1 in that order to the sequence [12,10,4,3,5] yields 4, since :
con([12,10,4,3,5],2) = [12,6,3,5]
con([12,6,3,5] ,3) = [12,6,-2]
con([12,6,-2] ,2) = [12,8]
con([12,8] ,1) = [4]
Given a sequence a1, a2, ..., aN and a target number T, the problem is to find a sequence of N-1 contractions that applied to the original sequence yields T.
输入格式
The first line of the input contains two integers separated by blank character : the integer N, 1 <= N <= 100, the number of integers in the original sequence, and the target integer T, -10000 <= T <= 10000. The following N lines contain the starting sequence : for each i, 1 <= i <= N, the (i+1)st line of the input file contains integer ai, 1 <= ai <= 100.
输出格式
Output should contain N-1 lines, describing a sequence of contractions that transforms the original sequence into a single element sequence containing only number T. The ith line of the output file should contain a single integer denoting the ith contraction to be applied. You can assume that at least one such sequence of contractions will exist for a given input.
样例输入
5 4
12
10
4
3
5
样例输出
2
3
2
1
题目大意
给定一个序列a，每次可以选择两个数a[i]和a[i+1]，从序列中将这两个数替换为一个数a[i]-a[i+1]。求最少的操作方案使最后剩下的数为给定的t。
题解
假设我们有三个数i,j,k，如果我们首先将j和k合并，得到了i和j-k。接下来把剩下两个数合并，最后的结果为i-(j-k)=i-j+k。换一种方式，首先合并i和j，得到i-j和k，再合并两个数，得到的最后结果为i-j-k。容易发现，最后的结果其实是由序列中的数通过加和减的操作得来的。那么问题就转化为对一个序列加入加号和减号，使其最后计算出的结果为t。由于最后要求输出方案，我们可以利用动态规划来完成。设\(f[i][j]\)表示在第i个数、前面计算结果为j时第i个数为加还是减。那么状态转移方程为：
其中1表示为加号，0表示为减号。那么我们怎么推出方案呢？已知最后的结果为t，那么可以用倒推法，一步一步地推出方案。假设当前结果为s，如果\(f[i][s]\)为1，说明这个数取正，同时使s减去a[i]。反之取负，同时s加上a[i]。如此往复。但怎么推出是第几个呢？我们不妨这样做：首先把所有加号处理完，然后一起输出减号。因为如果最后只剩减号的话，可以一直输出1而没有对位置的影响。那么现在考虑加号的决策。如果一个值取得为加号，那么在此之前这个数一定是被合并过的。记前面进行过的操作次数为cnt。那么这个数的位置一共被向前推移了cnt次。但按照输出规则，应当输出它的前一个数(前一个数和该数合并)。
代码
#include <iostream>
#include <cstdio>
#include <cstring>
#define N 102
#define M 10002
using namespace std;
const int T=10000;
int n,t,i,j,a[N],f[N][M*2],opt[N];
int main()
{
cin>>n>>t;
for(i=1;i<=n;i++) cin>>a[i];
memset(f,-1,sizeof(f));
f[1][a[1]+T]=1;
f[2][a[1]-a[2]+T]=0;
for(i=3;i<=n;i++){
for(j=0;j<=2*T;j++){
if(f[i-1][j]!=-1){
f[i][j+a[i]]=1;
f[i][j-a[i]]=0;
}
}
}
j=t+T;
for(i=n;i>=1;i--){
if(f[i][j]==1){
opt[i]=1;
j-=a[i];
}
else if(f[i][j]==0){
opt[i]=0;
j+=a[i];
}
}
int cnt=0;
for(i=2;i<=n;i++){
if(opt[i]==1){
cout<<i-cnt-1<<endl;
cnt++;
}
}
for(i=2;i<=n;i++){
if(opt[i]==0) cout<<"1"<<endl;
}
return 0;
}
