算法实验题4.4 逆序表问题（DP or 二分 or 线段树）

题目描述

---

思路

这个问题大致就是给你1~n数字对应的逆序数分别存到b[n]中，然后让你还原出原序列

• 动态规划

我们虽然不知道原序列长啥样，但我们知道它每个元素长啥样。并且最大那个数无论放到哪逆序数都是为0，于是先把这个数加到结果集中。问题就变成倒2个数根据逆序数考虑排倒结果集的位置，不难发现一个数字k他的逆序数s应满足$0<=s<=n-k$。于是问题就变成根据逆序数去找位置插入。为什么说这是动态规划？因为发现每次一个小的数能做都依赖于比他的的数的形状，并且它不会改变之前的相对位置关系，也就是说满足最优子问题、无后效性、子问题重叠。

至于复杂度由于是索引加插入，复杂度$O(n^2)$

---

• 二分

这个算法是问题的标程，并且是用问题给的定义和数据结构要求。但我不太理解这个算法，故这里只贴出一位叫应明明PPT中的解决方案。大致是利用定义的式子消去逆序数，也就是那个可以被证明的式子。而利用像分治的二分递归满足复杂度为$O(nlogn)$的要求。

转自:https://www.doc88.com/p-9405108317537.html（侵删）




分治并将求出来的序列存到r中：

治：（核心算法！）

主函数调用：

---

• 线段树

线段树维护区间的逆序数最小且最靠左的逆序数min（b[p]）,以及p（那个最小的数）

• 第k次查询[1,n]中的那个数字p即为原序列中的第k个数；
• 查询后要把线段树中p这个位置的数单点更新为INF，摆脱对全局的贡献，注意这个INF要尽量大防止后面在区间更新的时候又被减回来
• 把[1,p)的区间逆序数-1，用来让这个数对后面没输出且得到该数贡献的逆序数消去1，因为这个数以后都不再对他们造成贡献了，注意p>1
  
  下面给出线段树方案的实现，复杂度:$O(nlogn)$，不过没达到题目中要求的数据结构。

勘误，之前会错题意了，我这个线段树的版本是解决1-n这几个数字对应的逆序数还原排列而不是解决1-n这几个位置对应逆序数还原排列。而正解下面给出例题：poj2182、hdu5592、fzu2184

---

实现

#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5+5;
const int INF = 0x2f3f3f3f;

int b[N], n;
int seq[N];

struct Node {
	//区间[1,n]内最靠左逆序数最小的元素
	int id, min; //元素，逆序数
	int l, r;
	int lazy_tag;
}BTree[N<<2];

inline void Push_Up(int idx) {
	if(BTree[idx << 1].min <= BTree[idx << 1 | 1].min) {
		BTree[idx].min = BTree[idx << 1].min;
		BTree[idx].id = BTree[idx << 1].id;
	} else {
		BTree[idx].min = BTree[idx << 1 | 1].min;
		BTree[idx].id = BTree[idx << 1 | 1].id;
	}
}

inline void Push_Down(int idx) { //标记下放
	if(BTree[idx].lazy_tag ^ 0) {
		BTree[idx << 1].min += BTree[idx].lazy_tag;
		BTree[idx << 1 | 1].min += BTree[idx].lazy_tag;
		BTree[idx << 1].lazy_tag = BTree[idx].lazy_tag;
		BTree[idx << 1].lazy_tag = BTree[idx].lazy_tag;
		BTree[idx].lazy_tag = 0;
	}
}

void Build(int l, int r, int idx) {
	BTree[idx].l = l;
	BTree[idx].r = r;
	BTree[idx].lazy_tag = 0;
	if(l == r) {
		BTree[idx].id = l;
		BTree[idx].min = b[l];
		return ;
	}
	int mid = l + (r - l >> 1);
	Build(l, mid, idx << 1);
	Build(mid+1, r, idx << 1 | 1);
	Push_Up(idx);
}

//区间[l,r]+k
void Updates(int l, int r, int k, int idx) {
	if(BTree[idx].l>=l && BTree[idx].r<=r) {
		BTree[idx].lazy_tag = k;
		BTree[idx].min += k;
		return ;
	}
	Push_Down(idx);
	int mid = BTree[idx].l + (BTree[idx].r - BTree[idx].l >> 1);
	if(r <= mid) Updates(l, r, k, idx << 1);
	else if(l > mid) Updates(l, r, k, idx << 1 | 1);
	else {
		Updates(l, mid, k, idx << 1);
		Updates(mid+1, r, k, idx << 1 | 1);
	}
	Push_Up(idx);
}

//单点更新
void Update(int v, int k, int idx) {
	if (BTree[idx].l == v && BTree[idx].r == v) {
		BTree[idx].min = k;
		BTree[idx].lazy_tag = 0;
		return ;
	}
	int mid = BTree[idx].l + (BTree[idx].r - BTree[idx].l >> 1);
	if(v <= mid) Update(v, k, idx << 1);
	else Update(v, k, idx << 1 | 1);
	Push_Up(idx);
}

//查询[l,r]中最靠左逆序数最小的元素
Node& Query(int l, int r, int idx) {
	if(BTree[idx].l >= l && BTree[idx].r <= r)
		return BTree[idx];
	Push_Down(idx);
	int mid = BTree[idx].l + (BTree[idx].r - BTree[idx].l >> 1);
	if(r <= mid) return Query(l, r, idx << 1);
	else if(l > mid) return Query(l, r, idx << 1 | 1);
	else {
		Node& el = Query(l, mid, idx << 1);
		Node& er = Query(mid+1, r, idx << 1 | 1);
		return el.min <= er.min ? el : er;
	}
}

int main() {
	cin >> n;
	for(int i=1; i<=n; i++) cin >> b[i]; //假设序列合法

	Build(1, n, 1);
	for(int i=1; i<=n; i++) {
		Node cur = Query(1, n, 1); //查询当前的数
		seq[i] = cur.id;
		if(seq[i] > 1) Updates(1, seq[i]-1, -1, 1); //把[1...seq[i])的逆序数消去1
		Update(seq[i], INF, 1); //本元素已不会再造成贡献了故设位INF
	}
	for(int i=1; i<=n; i++) cout << seq[i] << ' ';
	cout << endl;
	return 0;	
}

二分+树状数组（poj2182为例）

#include <iostream>
using namespace std;
const int N = (int)1e5+5;
int b[N], c[N], n, seq[N];

int lowbit(int x) {
	return x & (-x);
}

void add(int idx, int k) {
	while(idx <= n) {
		c[idx] += k;
		idx += lowbit(idx);
	}
}

int query(int idx) {
	int sum = 0;
	while(idx > 0) {
		sum += c[idx];
		idx -= lowbit(idx);
	}
	return sum;
}

int lower_bound(int eq) {
	int l=1, r=n+1;
	while(l<r) {
		int mid=l+(r-l>>1);
		int pre=query(mid)-1;
		if(pre>=eq) r=mid;
		else l=mid+1;
	}
	return l;
}

int main() {
	cin >> n;
	b[1] = 0;
	for(int i=2; i<=n; i++)
		cin >> b[i]; //每个位置对应的逆序数
	for(int i=1; i<=n; i++) add(i, 1); //初始化,1~n的数字都没被选过
	for(int i=n; i>=1; i--) {
		int pos=lower_bound(b[i]); //找到第一个b[i]逆序的数字
		seq[i]=pos;
		add(pos, -1);
	}
	for(int i=1; i<=n; i++) cout << seq[i] << endl;
	return 0;
}

关于线段树可以写成权值线段树，不过树状数组好写，但对于要二分的题目线段树可以消掉一个log的复杂度

hdu5592（找前面比该位置大b[i]的数）

#include <iostream>
#include <cstring>
using namespace std;
const int N = (int)1e5+5;
int b[N], c[N], n, seq[N];

int lowbit(int x) {
	return x & (-x);
}

void add(int idx, int k) {
	while(idx <= n) {
		c[idx] += k;
		idx += lowbit(idx);
	}
}

int query(int idx) {
	int sum = 0;
	while(idx > 0) {
		sum += c[idx];
		idx -= lowbit(idx);
	}
	return sum;
}

int lower_bound(int eq) {
	int l=1, r=n+1;
	while(l<r) {
		int mid=l+(r-l>>1);
		int pre=query(mid);
		if(pre>=eq) r=mid;
		else l=mid+1;
	}
	return l;
}

int main() {
	int T;
	cin >> T;
	while(T--) {
		cin >> n;
		memset(c, 0, sizeof(c));
		for(int i=1; i<=n; i++)
			cin >> b[i];
		for(int i=1; i<=n; i++) add(i, 1); //初始化,1~n的数字都没被选过
		//b[i]表示第i个数前面有多少比它大
		//c[i]表示<=i的数字还剩多少个
		//i-b[i]表示第i个数前面有多少比它小（不包括自己(i-1)-(b[i]-1)）
		for(int i=n; i>=1; i--) {
			int pos=lower_bound(i-(b[i]-b[i-1]));
			seq[i]=pos;
			add(pos, -1);
		}
		for(int i=1; i<=n; i++) cout << seq[i] << " \n"[i==n];
	}
	return 0;
}