codeforces 301D Yaroslav and Divisors

题目链接：http://codeforces.com/problemset/problem/301/D

题目大意：给定一个1~n的排列，以及m次询问，每次询问给出左右边界L，R，

要你求出下标在[L,R]的数中，有多少对数满足一个数能被另外一个整除。

算法与思路：一个数x在1~n内能被多少个数整除？答案是n/x；
则1~n中有多少对数满足一个数能被另外一个整除的答案是
sum[n]=n/1 + n/2 + …… + n/n；
则很自然的想法就是维护一个树状数组，认为sum[R]-sum[L-1]即是所求的的解；
但是事实上这个结果包含了一种应该剔除的特殊情况：a属于[1, L-1],b属于[L, R]，且b可被a整除；
所以需要在sum[R]-sum[L-1]剔除掉上述情况数目才是题目答案；

令i从1~n循环，对于每一个q1.l == i，ans[q1[j].pos]减去sum[R]-sum[L-1]，

由于此时只更新完下标[1, L]的数的倍数，所以实际减去的值就是特殊情况的数量；

而在更新完[1, R]之后，对于每一个q2.l == i，ans[q2[k].pos]加上sum[R]-sum[L-1]，得到最终的结果。

代码实现：

#include<stdio.h>
#include<algorithm>
using namespace std;
const int Maxn = 200005;
int n, m;
int a[Maxn], Pos[Maxn], bit[Maxn] = {0};
int ans[Maxn] = {0};
int lowbit(int x)
{
	return x & (-x); 
} 
int sum(int x)
{
	int res = 0;
	while(x > 0)
	{
		res += bit[x];
		x -= lowbit(x); 
	}
	return res;
} 
void update(int x, int val)
{
	while(x <= n)
	{
		bit[x] += val;
		x += lowbit(x); 
	}
}
struct node
{
	int pos, l, r;
}q1[Maxn], q2[Maxn];
bool cmp1(node a, node b)
{
	return a.l < b.l;
}
bool cmp2(node a, node b)
{
	return a.r < b.r;
}
int main()
{
	scanf("%d%d", &n, &m);
	for(int i = 1; i <= n; i++)
	{
		scanf("%d", &a[i]);
		Pos[a[i]] = i;
	} 
	for(int i = 1; i <= m; i++)
	{
		scanf("%d%d", &q1[i].l, &q1[i].r);
		q2[i].l = q1[i].l;
		q2[i].r = q1[i].r;
		q1[i].pos = q2[i].pos = i;
	} 
	sort(q1 + 1, q1 + m + 1, cmp1);
	sort(q2 + 1, q2 + m + 1, cmp2);
	for(int i = 1, j = 1, k = 1; i <= n; ++i)
	{
		while(j <= m && q1[j].l == i)
		{
			ans[q1[j].pos] -= sum(q1[j].r) - sum(q1[j].l - 1);
			++j;
		}
		for(int p = a[i]; p <= n; p += a[i])
		    update(Pos[p], 1);
		while(k <= m && q2[k].r == i)
		{
			ans[q2[k].pos] += sum(q2[k].r) - sum(q2[k].l - 1);
			++k;
		}
	} 
	for(int i = 1; i <= m; i++)
	    printf("%d\n", ans[i]);
	return 0;
}