Lucky HDU - 5213 (莫队,容斥)

WLD is always very lucky.His secret is a lucky number . is a fixed odd number. Now he meets a stranger with numbers:.The stranger asks him questions.Each question is like this:Given two ranges and ,you can choose two numbers and to make .The you can choose is between and and the you can choose is between and .How many pairs of numbers you can choose?
If WLD can answer all the questions correctly,he‘ll be the luckiest man in the world.Can you help him?
Input
There are multiple cases.(At MOST )

For each case:

The first line contains an integer .

The following line contains an integer ,WLD‘s lucky number.K is odd.

The following line contains integers .

The following line contains an integer ,the sum of the questions WLD has to answer.

The following lines,the i-th line contains numbers ,describing the i-th question the stranger asks.
Output
For each case:

Print the total of pairs WLD can choose for each question.
Sample Input
5
3
1 2 1 2 3
1
1 2 3 5
Sample Output
2

Hint
a1+a4=a2+a3=3=K.
So we have two pairs of numbers (1,4) and (2,3).
Good luck!

题意:

给你一个长度为n的数组a,以及一个整数k,和m个询问。

每一个询问给你两个区间分别是 l~r,u~v,

问你有多少对 x,y 满足 a[x]+a[y]=k 并且 l<=x<=r, u<=y<=v

思路:

由于题目的数据范围和支持离线做法,我们容易想到莫队算法

但是我们知道莫队算法只可以处理一个连续的区间问题,不能处理两段连续的区间。

那么我们来考虑能否将两段区间转化为一个连续区间的问题。

我们设F(i,j ) 为 在区间i~j中,x,y (x!=y)满足 a[x]+a[y]=k 的个数。

那么根据容斥定律,我们可以知道。、

F(l1,r1)+F(l2,r2) = F(l1,r2) - F(l1,l2-1 ) - F(r1+1,r2)+F(r1+1,l2-1)

那么我们就可以把问题转化为莫队经典的区间询问问题了。

我们把每一个询问分成上面等式右边的四个部分,同时对于每一个部分维护它对这个询问的贡献是加还是减。

多组输入,记得初始化即可。

细节见代码:

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <vector>
#include <iomanip>
#define ALL(x) (x).begin(), (x).end()
#define sz(a) int(a.size())
#define all(a) a.begin(), a.end()
#define rep(i,x,n) for(int i=x;i<n;i++)
#define repd(i,x,n) for(int i=x;i<=n;i++)
#define pii pair<int,int>
#define pll pair<long long ,long long>
#define gbtb ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
#define MS0(X) memset((X), 0, sizeof((X)))
#define MSC0(X) memset((X), '\0', sizeof((X)))
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define eps 1e-6
#define gg(x) getInt(&x)
#define chu(x) cout<<"["<<#x<<" "<<(x)<<"]"<<endl
using namespace std;
typedef long long ll;
ll gcd(ll a, ll b) {return b ? gcd(b, a % b) : a;}
ll lcm(ll a, ll b) {return a / gcd(a, b) * b;}
ll powmod(ll a, ll b, ll MOD) {ll ans = 1; while (b) {if (b % 2) { ans = ans * a % MOD; } a = a * a % MOD; b /= 2;} return ans;}
inline void getInt(int *p);
const int maxn = 1000010;
const int inf = 0x3f3f3f3f;
/*** TEMPLATE CODE * * STARTS HERE ***/
ll ans[maxn];
ll Ans = 0ll;
int l = 1;
int r = 0;
struct node {
    int l, r, id;
    int op;
} a[maxn];
int pos[maxn];
int n, m;
int len;
bool cmp(node aa, node bb)
{
    if (pos[aa.l] == pos[bb.l]) {
        return aa.r < bb.r;
    } else {
        return pos[aa.l] < pos[bb.l];
    }
}
int col[maxn];
int flag[maxn];
int k;
int cnt = 0;
void add(int x)
{
    if ((k >= col[x])) {
        Ans += flag[k - col[x]];
    }
    flag[col[x]]++;
}

void del(int x)
{
    flag[col[x]]--;
    if((k>=col[x]))
        Ans-=flag[k-col[x]];
}
int main()
{
    //freopen("D:\\code\\text\\input.txt","r",stdin);
    //freopen("D:\\code\\text\\output.txt","w",stdout);
    while(~scanf("%d%d",&n,&k))
    {

        len = (int)(sqrt(n));
        repd(i, 1, n) {
            gg(col[i]);
        }
        gg(m);
        repd(i,1,max(n,m))
        {
            ans[i]=0ll;
            flag[i]=0ll;
        }
        cnt=0;
        int l1, l2, r1, r2;
        repd(i, 1, m) {
            pos[i] = i / len;
            gg(l1); gg(r1); gg(l2); gg(r2);
            a[++cnt].l = l1; a[cnt].r = r2; a[cnt].op = 1;a[cnt].id = i;
            a[++cnt].l = l1; a[cnt].r = l2-1; a[cnt].op = -1;a[cnt].id = i;
            a[++cnt].l = r1+1; a[cnt].r = r2; a[cnt].op = -1;a[cnt].id = i;
            a[++cnt].l = r1+1; a[cnt].r = l2-1; a[cnt].op = 1;a[cnt].id = i;
        }
        sort(a + 1, a + 1 + cnt, cmp);
        repd(i, 1, cnt) {
            while (l > a[i].l) {
                l--;
                add(l);
            }
            while (r < a[i].r) {
                r++;
                add(r);
            }
            while (l < a[i].l) {
                del(l);
                l++;
            }
            while (r > a[i].r) {
                del(r);
                r--;
            }
    //        cout<<a[i].l<<" "<<a[i].r<<" "<<Ans<<" "<<a[i].op<<endl;
            ans[a[i].id] += Ans * a[i].op;
        }
        repd(i, 1, m) {
            printf("%lld\n", ans[i]);
        }
    }

    return 0;
}

inline void getInt(int *p)
{
    char ch;
    do {
        ch = getchar();
    } while (ch == ' ' || ch == '\n');
    if (ch == '-') {
        *p = -(getchar() - '0');
        while ((ch = getchar()) >= '0' && ch <= '9') {
            *p = *p * 10 - ch + '0';
        }
    } else {
        *p = ch - '0';
        while ((ch = getchar()) >= '0' && ch <= '9') {
            *p = *p * 10 + ch - '0';
        }
    }
}

原文地址:https://www.cnblogs.com/qieqiemin/p/11366519.html

时间: 2024-07-30 00:19:09

Lucky HDU - 5213 (莫队,容斥)的相关文章

HDU 5321 Beautiful Set 容斥 (看题解)

HDU 5321 感觉有点抗拒这种题目, 看到就感觉自己不会写,其实就是个沙雕题, 感觉得找个时间练练这种题. g[ i ] 表示gcd为 i 的倍数的方案数, f[ i ] 表示gcd为 i 的方案数, 然后先算g[ i ]然后直接容斥. #pragma GCC optimize(2) #pragma GCC optimize(3) #include<bits/stdc++.h> #define LL long long #define LD long double #define ull

HDU 4135 Co-prime(容斥+数论)

Co-prime Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 5526    Accepted Submission(s): 2209 Problem Description Given a number N, you are asked to count the number of integers between A and B

HDU 5297 Y sequence 容斥/迭代

Y sequence Problem Description Yellowstar likes integers so much that he listed all positive integers in ascending order,but he hates those numbers which can be written as a^b (a, b are positive integers,2<=b<=r),so he removed them all.Yellowstar ca

HDU 3970 Harmonious Set 容斥欧拉函数

链接 题解:www.cygmasot.com/index.php/2015/08/17/hdu_3970 给定n 求连续整数[0,n), 中任意选一些数使得选出的数和为n的倍数的方法数 ...并不会如何递推.. 思路: 然后这是公式:点击打开链接 a(n) = 1/n * sum_{d divides n and d is odd} 2^(n/d) * phi(d). d最大是n,也就是1e9,要计算1e9的phi,所以容斥来算phi. #pragma comment(linker, "/STA

HDU 4135 Co-prime(组合+容斥)

Problem Description Given a number N, you are asked to count the number of integers between A and B inclusive which are relatively prime to N. Two integers are said to be co-prime or relatively prime if they have no common positive divisors other tha

HDU 4609 3-idiots FFT+容斥

一点吐槽:我看网上很多分析,都是在分析这个题的时候,讲了半天的FFT,其实我感觉更多的把FFT当工具用就好了 分析:这个题如果数据小,统计两个相加为 x 的个数这一步骤(这个步骤其实就是求卷积啊),完全可以母函数,无奈数据很大,就用FFT了 然后难点在于最后的统计,要减去自身,两个都大的,一大一小,包含自身,这是用到了容斥,再做相似的题的时候,应该多看看这方面 注:再次高度仰慕kuangbin神,这是我FFT的第二题,也是第二次用kuangbin FFT模板 #include <stdio.h>

HDU 4638 莫队算法

Group Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 2483    Accepted Submission(s): 1272 Problem Description There are n men ,every man has an ID(1..n).their ID is unique. Whose ID is i and i-

HDU 4638 (莫队)

题目链接:Problem - 4638 做了两天莫队和分块,留个模板吧. 当插入r的时候,设arr[r]代表r的位置的数字,判断vis[arr[r-1]]和vis[arr[r+1]]是否访问过,如果两个都访问过,那么块的个数-1,如果有一个访问过,块的个数不变,如果都为0,块的个数+1. 1 #include <iostream> 2 #include <cstdio> 3 #include <cstring> 4 #include <algorithm>

HDU 1695 GCD(容斥定理)

GCD Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 7529    Accepted Submission(s): 2773 Problem Description Given 5 integers: a, b, c, d, k, you're to find x in a...b, y in c...d that GCD(x, y