Description
给定序列A，序列中的每一项Ai有删除代价Bi和附加属性Ci。请删除若
干项，使得4的最长上升子序列长度减少至少1，且付出的代价之和最小，并输出方案。
如果有多种方案，请输出将删去项的附加属性排序之后，字典序最小的一种。
Input
输入包含多组数据。
输入的第一行包含整数T，表示数据组数。接下来4*T行描述每组数据。
每组数据的第一行包含一个整数N，表示A的项数，接下来三行，每行N个整数A1．．An，B1．，Bn，C1．．Cn，满足1 < =Ai，Bi，Ci < =10^9，且Ci两两不同。
Output
对每组数据，输出两行。第一行包含两个整数S，M，依次表示删去项的代价和与数量；接下来一行M个整数，表示删去项在4中的的位置，按升序输出。
Sample Input
1
6
3 4 4 2 2 3
2 1 1 1 1 2
6 5 4 3 2 1
6
3 4 4 2 2 3
2 1 1 1 1 2
6 5 4 3 2 1
Sample Output
4 3
2 3 6
解释：删去(A2，43，A6)，(A1，A6)，(A2，43，44，A5)等都是合法的方案，但
{A2，43，A6)对应的C值的字典序最小。
2 3 6
解释：删去(A2，43，A6)，(A1，A6)，(A2，43，44，A5)等都是合法的方案，但
{A2，43，A6)对应的C值的字典序最小。
HINT
1 < =N < =700 T < =5
题解Here!
LIS最小割：
拆点，所有$X_j$向$Y_j$连权值边；
对于$A[k]<A[j]$，且$f[j]==f[k]+1$的点$Y_k$和$X_j$之间连流量为$MAX$边；
对于$f[j]==1$的点连$S$和$X$的流量为$MAX$边，对于$f[j]==maxn$的点$Y$和$T$的连流量为$MAX$边。
但输出方案要求字典序最小，贪心选择最小的可能存在在最小割中的边。
这里的边是连接同一点$X$和$Y$的边，在最小割上满足且仅满足$ ext{满流}&& ext{不能增广}$两个条件。
选择一条边后要删除它对其他边选择的影响，所以退流：
边的靠$S$端点向$S$退边权流，$T$端点向靠$T$端点退边权流。
退流就是更改源点和汇点，然后倒着跑一次$Dinic$。
附代码：
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<queue>
#include<cstring>
#define MAXN 1410
#define MAXM 1000010
#define MAX (1<<30)
using namespace std;
int n,S,T,c;
int head[MAXN],deep[MAXN],id[MAXN];
int top=0,ans[MAXN];
int A[MAXN],B[MAXN],C[MAXN],num[MAXN],dp[MAXN];
struct Edge{
int next,to;
long long w;
}a[MAXM<<1];
inline int read(){
int date=0,w=1;char c=0;
while(c<'0'||c>'9'){if(c=='-')w=-1;c=getchar();}
while(c>='0'&&c<='9'){date=date*10+c-'0';c=getchar();}
return date*w;
}
inline bool cmp(const int &x,const int &y){
return C[x]<C[y];
}
inline void add(int u,int v,int w){
a[c].to=v;a[c].w=w;a[c].next=head[u];head[u]=c++;
a[c].to=u;a[c].w=0;a[c].next=head[v];head[v]=c++;
}
bool bfs(int s,int t){
int u,v;
queue<int> q;
for(int i=1;i<=T;i++)deep[i]=0;
deep[s]=1;
q.push(s);
while(!q.empty()){
u=q.front();
q.pop();
for(int i=head[u];i;i=a[i].next){
v=a[i].to;
if(a[i].w&&!deep[v]){
deep[v]=deep[u]+1;
if(v==t)return true;
q.push(v);
}
}
}
return false;
}
long long dfs(int x,long long limit,int t){
if(x==t)return limit;
int v;
long long sum,cost=0;
for(int i=head[x];i;i=a[i].next){
v=a[i].to;
if(a[i].w&&deep[v]==deep[x]+1){
sum=dfs(v,min(a[i].w,limit-cost),t);
if(sum>0){
a[i].w-=sum;
a[i^1].w+=sum;
cost+=sum;
if(limit==cost)break;
}
else deep[v]=-1;
}
}
return cost;
}
int dinic(int s,int t,long long ans){
while(bfs(s,t))ans+=dfs(s,MAX,t);
return ans;
}
bool check(int x){
return (!(a[id[x]].w||bfs(x,x+n)));
}
void solve(){
top=0;
for(int i=1;i<=n;i++)num[i]=i;
sort(num+1,num+n+1,cmp);
for(int i=1;i<=n;i++)if(check(num[i])){
ans[++top]=num[i];
dinic(T,num[i]+n,B[num[i]]);
dinic(num[i],S,B[num[i]]);
a[id[num[i]]].w=a[id[num[i]]^1].w=0;
}
}
void work(){
printf("%d ",dinic(S,T,0));
solve();
printf("%d
",top);
sort(ans+1,ans+top+1);
for(int i=1;i<=top;i++)printf("%d ",ans[i]);
printf("
");
}
void init(){
int maxn=0;
c=2;
memset(head,0,sizeof(head));
n=read();
S=(n<<1)+1;T=(n<<1)+2;
for(int i=1;i<=n;i++)A[i]=read();
for(int i=1;i<=n;i++)B[i]=read();
for(int i=1;i<=n;i++)C[i]=read();
for(int i=1;i<=n;i++){
dp[i]=1;
for(int j=1;j<i;j++)if(A[j]<A[i])dp[i]=max(dp[i],dp[j]+1);
maxn=max(maxn,dp[i]);
}
for(int i=1;i<=n;i++){
if(dp[i]==1)add(S,i,MAX);
else{
if(dp[i]==maxn)add(i+n,T,MAX);
for(int j=1;j<i;j++)if(A[j]<A[i]&&dp[i]==dp[j]+1)add(j+n,i,MAX);
}
id[i]=c;
add(i,i+n,B[i]);
}
}
int main(){
int t=read();
while(t--){
init();
work();
}
return 0;
}