题目一

方法一

归并分治

代码：

# include <stdio.h>

int arr[100];
int help[100];

int n;

//归并分治
// 1.统计i、j来自 l~r 范围的情况下，逆序对数量
// 2.统计完成后，让arr[l...r]变成有序的 
int f(int l, int r)
{
	if (l == r)
		return 0;
	int m = (l + r) / 2;
	return f(l, m) + f(m+1, r) + merge(l, m, r);
}

int merge(int l, int m, int r)
{
	//i 来自 l...m
	//r 来自 m+1....r
	//统计有多少逆序对 
	int ans = 0;
	int j = r;
	for (int i=m; i>=l; --i)
	{
		while (j >= m+1 && arr[i] <= arr[j])
			j = j - 1;
		ans = ans + j - m;
	}
	
	//左右部分合并，整体变有序，归并排序的过程 
	int k = l;
	int a = l;
	int b = m + 1;
	while (a <= m && b <= r)
	{
		if (arr[a] <= arr[b])
		{
			help[k] = arr[a];
			a = a + 1;
		}
		else
		{
			help[k] = arr[b];
			b = b + 1;
		}
		k = k + 1;
	}
	while (a <= m)
	{
		help[k] = arr[a];
		k = k + 1;
		a = a + 1;
	}
	while (b <= m)
	{
		help[k] = arr[b];
		k = k + 1;
		b = b + 1;
	}
	for (i = l; i <= r; ++i)
		arr[i] = help[i];
	return ans; 
}

int main()
{
	scanf("%d", &n);
	for (int i=0; i<n; ++i)
		scanf("%d", &arr[i]);
	
	int ans = f(0, n-1);
}

方法二

树状数组

我们假设一个数组arr

建立一个词频数组

用于记录数字出现的次数

因为arr数组中最大的数字为100

所以只要建立一个长度为100的词频数组即可

我们对原数组从右往左进行考虑

先考虑arr[8]（也就是2）

对于逆序对，i  <  j，并且arr[i] > arr[j]

因此我们只要统计小于2的数，在词频数组中的和即可

也就是词频数组中下标2之前的前缀和

在统计完sum后，再将2添加进词频数组中

这时，我们就可以把词频数组转为树状数组

以上的操作就变为了

单点修改和区间查询

注意：

此时要考虑树状数组长度的问题！！！

因为词频数组的长度是由原数组最大值决定的，可能会出现过大的情况

此时就要进行离散化处理！

我们可以假设另外一个数组help

将原数组按照从小到大的顺序填入help数组中

并进行去重（可以使用双指针）

然后通过help数组对arr数组进行修改

利用二分

找到原数组中的数字在help数组中的下标位置

并将该数字修改为help数组中的下标的值

  

再对此时的arr数组进行词频统计建立树状数组

代码：

# include <stdio.h>
# include <stdlib.h>
int arr[100];
int sort[100];
int tree[100];

int n, m;

int cmp(const void* a, const void* b)
{
	int p1 = *(int*)a;
	int p2 = *(int*)b;
	return p1 - p2;
}

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

void add(int i, int v)
{
	while (i <= m)
	{
		tree[i] = tree[i] + m;
		i = i + lowbit(x);
	}
}

int sum(int i)
{
	int ans = 0;
	while (i > 0)
	{
		ans = ans + tree[i];
		i = i - lowbit(i;)
	}
	return ans;
}


// 给定原始值v
// 返回sort数组中1~m的下标 
int rank(int v) 
{
	int l = 1;
	int r = m;
	int mid;
	int ans = 0;
	while (l<=r)
	{
		mid = (l + r) / 2;
		if (sort[mid] >= v)
		{
			ans = mid;
			r = mid - 1;
		}
		else
		{
			l = mid + 1;
		}
	}
	return ans;
}

int main()
{
	scanf("%d", &n);
	for (int i = 1; i <= n; ++i)
	{
		scanf("%d", arr[i]);
		sort[i] = arr[i];
	}
	qsort(sort, sizeof(int), n, cmp);
	m = 1;
	for (int i=2; i <= n; ++i)
	{
		if (sort[i] != sort[m])
		{
			m = m + 1;
			sort[m] = sort[i];
		}
	}
	int ans = 0;
	for (int i=1; i<=n; ++i)
		arr[i] = rank(arr[i]);
	
	for (int i=n; i>=1; --i)
	{
		//增加当前数字的词频 
		add(arr[i], 1);
		// 右边有多少数字是 <= 当前数值 - 1 
		ans = ans + sum(arr[i]-1);
	}
	printf("%d", ans);
}

两个方法的区别：

归并分治实现：无需离散化代码、使用空间少、常数时间优良，不能实时查询，只能是离线的批量过程

树状数组实现：需要离散化代码、使用空间多、常数时间稍慢，可以实时查询

题目二(典型)

我们建立两个数组up1， up2

up1[ i ]：以下标 i 做结尾的升序的只有一个元素的数量

up2[ i ]：以下标 i 做结尾的升序的含有两个元素的数量

假设数组arr为：

从左往右进行处理

我们加入第一个数字为arr[1] = 1

先判断以 1 做结尾的升序的含有三个元素的数量

我们发现该值就是在up2数组中小于1的前缀和

然后再更新以 1 做结尾的升序的含有两个个元素的数量（也就是up2[1]）

我们发现该值就是在up1数组中小于1的前缀和

找到该值后，填入up2[1]

更新以 1 做结尾的升序的含有一个元素的数量（也就是up1[1]）

依次对 arr 数组从左往右进行遍历

因此，我们先对数组中的元素进行离散化处理

然后从左往后按照上述步骤进行

代码：

# include <stdio.h>
# include <string.h>
//记录原数组 
int arr[100];

//建立去重离散化数组 
int sort[100];

//维护信息：up1
//tree1不是up1数组，是up1数组的树状数组 
int tree1[100]; 

//维护信息：up2
//tree2不是up2数组，是up2数组的树状数组 
int tree2[100];

int n, m;

int cmp(const void* a, const void* b)
{
    int* p1 = (int*)a;
    int* p2 = (int*)b;
    return *p1 - *p2;
}

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

void add(int* tree, int i, int v)
{
	while (i <= m)
	{
		tree[i] = tree[i] + v;
		i = i + lowbit(i);
	}
}

int sum(int* tree, int i)
{
	int ans = 0;
	while (i > 0)
	{
		ans = ans + tree[i];
		i = i - lowbit(i);
	}
	return ans;
}

int rank(int x)
{
	int l = 1;
	int r = m;
	int mid;
	int ans = 0;
	while (l <= r)
	{
		mid = (l + r) / 2;
		if (sort[mid] >= v)
		{
			ans = mid;
			r = mid - 1;
		}
		else	
			l = mid + 1;
	}
	return ans;
}

int main()
{
	scanf("%d", &n);
	for (int i=1; i<=n; ++i)
	{
		scanf("%d", &arr[i]);
		sort[i] = arr[i];
	}
    qsort(sort, sizeof(int), n, cmp);
	m = 1;
	for (int i=2; i<=n; ++i)
	{
		if (sort[m] != sort[i])
		{
			m = m + 1;
			sort[m] = sort[i];
		}
	}
	for (int i=1; i<=n; ++i)
		arr[i] = rank(arr[i]);
	
	
	int ans = 0;
	for (int i=1; i<=n; ++i)
	{
		ans = ans + sum(tree2, arr[i] - 1);
		add(tree1, arr[i], 1);
		add(tree2, arr[i], sum(tree2, arr[i] - 1));
	}	
	printf("%d", ans);
}

题目三

我们建立一个结构

用于存储以下标 i 为结尾的子序列的最大长度和个数

# include <stdio.h>

struct node
{
	int len; //长度 
	int num; //个数 
};

//不是该结构数组，是该结构体的树状数组
//用于维护一个范围的最大长度和个数
struct node tree[100];

int arr[100];
int sort[100];

int n, m;

//查询结尾数值<=i的所有递增子序列中
//长度最大的递增子序列长度是多少，赋值给maxlen和maxnum
int maxlen, maxnum;

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

//以 i 这个值结尾的最长递增子序列达到了len长度
//并且这样的最长递增子序列的数量达到了cnt个
void add(int i, int l, int cnt)
{
	while (i <= m)
	{
		if (tree[i].len == l)
			tree[i].num = tree[i].num + cnt;
		else if (tree[i].len < l)
		{
			tree[i].len = l;
			tree[i].num = cnt;
		}
		i = i + lowbit(i);
	}
}

//结尾数值 <= i 的情况下，最长递增子序列的长度和个数为多少
void query(int x)
{
	maxlen = 0;
	maxnum = 0;
	while (x > 0)
	{
		if (tree[x].len == maxlen)
			maxnum = tree[x].num + maxnum;
		else if (tree[x].len > maxlen)
		{
			maxlen = tree[x].len;
			maxnum = tree[x].num;
		}
		x = x - lowbit(x);
	}
}

int rank(int x)
{
	int l = 1;
	int r = m;
	int mid;
	int ans;
	while (l <= r)
	{
		mid = (l+r) / 2;
		if (sort[mid] >= x)
		{
			r = mid - 1;
			ans = mid;
		}
		else
			l = mid + 1;
	}
	return ans;
}

int main()
{
	scanf("%d", &n);
	for (int i=1; i<=n; ++i)
	{
		scanf("%d", &arr[i]);
		sort[i] = arr[i];
	}
	qsort(sort, sizeof(sort), n, cmp);
	int m = 1;
	for (int i=2; i<=n; ++i)
	{
		if (sort[m] != sort[i])
		{
			sort[m] = sort[i];
			m = m + 1;
		}
	}
	memset(tree, 0, sizeof(tree));
	int y;
	for (int i=1; i<=m; ++i)
	{
		y = rank(arr[i]);
		query(y-1);
		add(y, maxlen+1, max(1, maxnum));
	}
	int ans = query(m);
	printf("%d", ans);
}

题目四

本题转化是非常巧妙的

我们首先需要对查询进行排序

按照 r 的大小进行排序

如图：

一个虚拟数组cnt[]（之所以说它是虚拟数组，因为可以用树状数组实现想要的操作，不需要真的定义这么一个数组）。

map[i] 记录 i 位置上的数上一次出现的位置

当遍历到原数组的下标 i 时，cnt[i]+1,如果 i 位的这个数之前出现过，即存在map[i]，则将cnt[map[i]]-1（在遍历到i之前已经遍历过last[i]位置了，因此cnt[map[i]]=1，所以这样操作下来，cnt[map[i]]=0)，不会对当前要求的结果造成影响

比如序列：2，3，4，3，4，2

当右边界为5时（下标从1开始），对应的cnt[]值分别为：1，0，0，1，1

所以区间【1，5】内不同的数字个数=3，区间【2，5】内不同的数字个数=2，区间【4，5】内不同的数字个数=2（树状数组累加和求解）

因为右边界一定，所以我们必须要确保选择的1是尽可能靠近右边界，确保答案正确

# include <stdio.h>
# include <string.h>
struct node
{
	int l;
	int r;
	int k;
};

int arr[100];

struct node query[100];

int ans[100];

int map[100];

int tree[100];

int n, m;

int compare(const void*a, const void* b)
{
	struct node* p1 = (struct node*)a;
	struct node* p2 = (struct node*)b;
	return *p1.r - *p2.r;
}

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

void add(int i, int v)
{
	while (i <= n)
	{
		tree[i] = tree[i] + v;
		i = i + lowbit(i);
	}
}

int q(int x)
{
	int ans = 0;
	while (x > 0)
	{
		ans = tree[x] + ans;
		x = x - lowbit(x);
	}
	return ans;
}

int range(int l, int r)
{
	return sum(r) - sum(l-1);
}

void cmp(void)
{
	 qsort(query, sizeof(struct node), m, compare);
	 int q = 1; //遍历询问 
	 int l;
	 int r;
	 int k; 
	 for (int q=1; q <= m; ++i)
	 {
	 	r = query[q].r;
	 	for (; s<=r; ++s)
	 	{
	 		int color = arr[s];
	 		if (map[color] != 0)
	 			add(map[color], -1)
	 		add[s, 1];
	 		map[color] = s;
		}
		l = query[q].l;
		k = query[q].k;
		ans[i] = range(l, r);
	 }
}

int main()
{
	scanf("%d", &n);
	for (int i=1; i<=n; ++i)
	{
		scanf("%d", &arr[i]);
	}
	scanf("%d", &m);
	for (int i=1; i<=m; ++i)
	{
		scanf("%d %d", &query[i].l, &query[i].r);
		query[i].k = i;
	}
	
	cmp();
	for (int i=1; i<=m; ++i)
		printf("%d", ans[i]);
}