2017.3.26 考试小结

关于考试：
痛苦并快乐地迎来了考试狂欢季…才刚把上次考试(3.23)考的题码完，就迎来了又一次考试，最近只能说爆0愉快了…
好吧，还是来说一下这次的考试…
总的来说呢，这次考试，除了第四题有思维难度外，个人感觉还是比较简单的。(当然考后GJY大神看了题，表示全是分分钟搞定的sb题…还能不能愉快的玩耍了…)
开始做题的时候，看到第一题，感到非常的愉快，就是一道简单的贪心，排个序就出来了，结果码代码地时候，再算数据范围的时候算错了点东西，总觉得求sum要超long long，然后就用double存，每个数都先除一个数，最后算完了，得到一个答案了(答案会比较小)然后再乘回去，结果好像中间过程的运算太多了，再乘回去就被卡精度，爆0了(大水题爆0好愉快啊…)，后来改成直接用long long存就A了…
然后就做第二题，也是道水题，没什么坑，也没什么好讲的，搞了两下就A了。
可是，看到第三题，就懵逼了，看了有10多分钟才搞懂到底是要干什么(语文不好的悲剧)…然后就开始想，先是在草稿纸上画了一堆情况来找规律。然后搞得似懂非懂了，结果最后在码代码的时候，有想偏了，就先放下去看第四题了，一看第四题，感觉熟悉，像是线段树，但想线段树又半天想不出来，时间复杂度就是过不去，当时就跟这道题杠上了，也没有回头去码第三题，搞得快结束的时候去码第三题，就只得了部分分(其实第三题最开始的想法就是正解，然后最后再去码的时候，就是在骗分了…好气啊…)
To sum up,好像第一题的细节类错误，已经不是第一次了…23号的考试好像也是因为这种错误导致了一道正解题爆0,怎么说呢，好像越是想细心，就越容易犯错…只有平时多注意，形成习惯，考试的时候就好了吧。希望下次不要再在这种错误上爆0，不然就真的哭晕在厕所了…然后就是，虽然想出来的方法不一定是对的，担又找不出来，数据来Wa掉它，那就勇敢的往上写吧，因为它往往都是对的，就算不对，也总比神么暴力骗分好得多啊…
关于考试就说这么多了，下面就来看一下题吧

---

Task1:银行账户

题目描述：

大家都知道28定律吧，据说世界上20%的人拥有80%的财富。现在你对一家银行的账户进行检测，看是否符合28定律，或者有更强的定律。比如说，10%的人拥有85%的财富。更准确的描述是：对N个银行账户进行调查，你的任务是找出两个数A,B，使得B-A的差最大。A，B的含义是A%的人拥有B%的财富。

输入：

输入的第一行包含一个整数N(1<=N<=300000)，表示银行账户的个数。
接下来一行包含N个整数,每个整数在区间[0,100000000],表示这N个账户中的存款金额。

输出：

输出两行，分别是两个实数A,B。A，B的含义如题所述。误差在0.01内可以接受。

样例输入：

2
100 200

样例输出：

50.0
66.66666666666666

解题思路：

大水题，没什么多说的，有点贪心的思路，直接看代码。

Code：

#include<cstdio>
#include<algorithm>
using namespace std;

typedef long long LL;
typedef double db;

const int MAXN = 300000;

template <class T>
inline void Read(T &Ret){
    char ch; int flg = 1;
    while(ch = getchar(), ch < '0' || ch > '9')
        if(ch == '-') flg = -1;
    Ret = ch - '0';
    while(ch = getchar(), ch >= '0' && ch <= '9')
        Ret = Ret * 10 + ch - '0';
    ungetc(ch, stdin); Ret *= flg;
}

bool cmp(const int &x, const int &y){return x > y;}

int n, arr[MAXN + 5];
LL sum, tmp_n, tmp_s;
db A, B;

int main(){
    Read(n);
    for(int i=1;i<=n;i++)
        Read(arr[i]),
        sum += arr[i];

    sort(arr + 1, arr + n + 1, cmp);

    db tmp1, tmp2;
    for(int i = 1; i <= n; ++ i){
        tmp_n += 1; tmp_s += arr[i];
        tmp1 = (db)tmp_n / n; tmp2 = (db)tmp_s / sum;
        if(tmp2 - tmp1 > B - A)  A = tmp1, B = tmp2;
        else break;
    }
    A *= 100, B *= 100;
    printf("%lf\n%lf\n",A,B);
    return 0;
}

---

Task2：染色面积

题目描述：

给你N个矩形，这些矩形在平面坐标系中，并且以坐标系的零点为中心，它们的边都平行于坐标轴。每个矩形由宽度和高度可以唯一确定。现在对矩形进行染色操作。下图即是样例的示意图：

现在请你计算有染色区域的面积。

输入：

第一行包含1个整数N(1<=n<=1000000),表示矩形的个数。
接下来N行包含两个偶数X和Y(2<=X,Y<=10000000),分别表示宽度和高度。

输出：

一行，表示区域面积。

样例输入：

3
8 2
4 4
2 6

样例输出：

28

解题思路：

因为所有的矩形都关于原点中心对称，所以在计算时就可以只考虑第一象限，最后用得到的答案ans*4就是最终答案了。至于在第一象限中，因为会有重复覆盖的区域，为了避免重复计算，我们可以按矩形左上角定点的y值排序(这里的写法是从大到小排的，也可以从小到大排，在计算的时候颠倒一下就行了，就相当于转了90°在看第一象限，实际上是一样的)这样，我们就可以得到按照y不上升排列的点集了，在这些点中我们只需按照顺序计算其与其前一个有效点(x的不下降序列里的点，因为保证的是y不上升，这时候如果后一个点的x<前一个点的x，那么这个点所围成的矩形区域，一定是被前面所覆盖了的，这样就可以避免重复计算)所在直线围成的矩形区域就行了。

Code：

#include<cstdio>
#include<algorithm>
using namespace std;

typedef long long LL;

const int MAXN = 1000000;

struct Point{
    int x, y;
    bool operator < (const node &p) const{
        if(y != p.y) return y > p.y;
        return x < p.x;
    }
};

Point arr[MAXN + 5];
LL ans;
int n;

template <class T>
inline void Read(T &Ret){
    char ch; int flg = 1;
    while(ch = getchar(), ch < '0' || ch > '9')
        if(ch == '-') flg = -1;
    Ret = ch - '0';
    while(ch = getchar(), ch >= '0' && ch <= '9')
        Ret = Ret * 10 + ch - '0';
    ungetc(ch, stdin); Ret *= flg;
}

int main(){
    Read(n);
    for(int i = 1; i <= n; ++ i){
        Read(arr[i].x); Read(arr[i].y);
        arr[i].x /= 2;
        arr[i].y /= 2;
    }

    sort(arr + 1, arr + n + 1);

    int tmp_x = 0;
    for(int i = 1; i <= n; ++ i){
        if(arr[i].x < tmp_x) continue;
        ans += (LL)(arr[i].x - tmp_x) * arr[i].y;
        tmp_x = arr[i].x;
    }

    ans *= 4;
    printf("%lld\n",ans);
    return 0;
}

---

Task3：航线变换

题目描述：

有N个城市，它们之间都有双向的航线。一个疯狂的航空公司老板经常改变航班日程。每天他都会做以下的事情：
1.选择一个城市
2.从该城市出发没有航线到达的城市全部开通航线，同时将之前开通的从该城市出发的所有航线全部取消

举个例子，比如从城市5出发，可以达到城市1和城市2，不能到达城市3和城市4，老板选择城市5做出改变后，那么城市5就有航班可以到达城市3和城市4，同时没有航班到达城市1和城市2了。

市民们想知道有没有一天，航线形成一个完全图。即每一个城市都有到达其他所有城市的航线，或者永远不可能形成一个完全图，不管老板如何操作。请写一个程序来判断。

输入：

第一行包含一个整数N(2<=N<=1000)，表示城市的数量。城市的编号从1到N
第二行包含一个整数M（0<=M<=N*(N-1)/2），表示当前航班的数量。
接下来M行，每行2个数x,y表示x和y城之间有航班。

输出：

有且只有一行，如果能够形成完全图，则输出DA，如果不能形成完全图，则输出NE

样例输入：

2
0

样例输出：

DA

解题思路：

通过证明，我们可以发现，仅当原图中仅有<=2个完全图，和<=2个单点(即没有边与之相连的的点)才可以在操作后构成一个完全图。所以我们可以采用dfs搜图，并进行判断。

Code:

#include<cstdio>

const int MAXN = 1000;
const int MAXM = MAXN * MAXN / 2;

struct node{int e, nxt;}line[MAXM + 5];
int fir[MAXN + 5], cnt;
bool vis[MAXN + 5];

template <class T>
inline void Read(T &Ret){
    char ch; int flg = 1;
    while(ch = getchar(), ch < '0' || ch > '9')
        if(ch == '-') flg = -1;
    Ret = ch - '0';
    while(ch = getchar(), ch >= '0' && ch <= '9')
        Ret = Ret * 10 + ch - '0';
    ungetc(ch, stdin); Ret *= flg;
}

inline void Insert(int a, int b){
    line[++ cnt].e = b;
    line[cnt].nxt = fir[a];
    fir[a] = cnt;
}

int tmp1, tmp2;
void dfs(int u){
    vis[u] = 1; tmp1 ++;
    for(int i = fir[u]; i; i = line[i].nxt){
        tmp2 ++;
        if(!vis[line[i].e]) dfs(line[i].e);
    }
}

int main(){
    int n, m, point = 0, mp = 0;
    Read(n); Read(m);
    int x, y;
    while(m --){
        Read(x); Read(y);
        Insert(x, y);
    }

    for(int i = 1; i <= n; ++ i){
        if(vis[i]) continue;
        tmp1 = tmp2 = 0;
        dfs(i);
        if(tmp1 == 1) point ++;
        else if(tmp1 * (tmp1 - 1) / 2 == tmp2)
            mp ++;
        else{
            printf("NE\n");
            return 0;
        }
        if(point > 2 || mp > 2){
            printf("NE\n");
            return 0;
        }
    }
    printf("DA\n");
    return 0;
}

---

Task4:数组查询

题目描述：

Mirko是一个非常单纯的人，他的好朋友给他一个有N个自然数的数组，然后对他进行Q次查询.
每一次查询包含两个正整数L,R，表示一个数组中的一个区间[L,R]，Mirko需要回答在这个区间中有多少个值刚好出现2次。

输入：

第一行包含两个整数N和Q(1<=N,Q<=500000)
第二行包含N个自然数，这些数均小于1000000000，表示数组中的元
接下来有Q行，每行包含两个整数L和R(1<=L<=R<=N)。

输出：

输出包含Q行，每行包含一次查询的答案。

样例输入：

5 1
1 2 1 1 1
1 3

样例输出：

1

解题思路：

首先，我们可以很轻易地得知，一个元素如果要对[l, r]这个区间内的答案产生贡献，那么，在[l, r]内，这个元素就只能出现两次，即在[l, r]内第一个出现的k元素不会对答案产生贡献，第二次出现的k元素会对答案有+1的贡献，而第三次出现的k元素则会对答案产生-1的贡献。所以，对此，我们可以知道对于一个固定的r， 和一个在[1, r]内移动的l，如果在区间内的一个元素，我们只需要在这个元素的第二次出现的前一个位置+1，后一个位置-1就行了。
鉴于这种思路，这道题需要使用离线做法(即把所有的询问先存下来，统一处理，而不是读入一次询问，就处理一次)。

Code：

#include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;

const int INF = 0x7f7f7f7f;
const int MAXN = 500000;

struct Question{
    int id, l;
    Question(){}
    Question(int a, int b){id = a, l = b;}
};

struct sr{
    int v, id;
    bool operator < (const sr &x) const{
        return v < x.v;
    }
};

sr tmp[MAXN + 5];
vector <Question> R[MAXN + 5];
int n, m;
int A[MAXN + 5], ans[MAXN + 5];
int pos[MAXN + 5][4];

template <class T>
inline void Read(T &Ret){
    char ch; int flg = 1;
    while(ch = getchar(), ch < '0' || ch > '9')
        if(ch == '-') flg = -1;
    Ret = ch - '0';
    while(ch = getchar(), ch >= '0' && ch <= '9')
        Ret = Ret * 10 + ch - '0';
    ungetc(ch, stdin); Ret *= flg;
}

#define lowbit(x) (x & -x)
int arr[MAXN + 5];

inline void Insert(int u, int v){
    while(u <= n){
        arr[u] += v;
        u += lowbit(u);
    }
}

inline int getsum(int u){
    int sum = 0;
    while(u){
        sum += arr[u];
        u -= lowbit(u);
    }
    return sum;
}

void pre(){
    sort(tmp + 1, tmp + n + 1);
    for(int i = 1; i <= n; ++ i){
        A[tmp[i].id] = A[tmp[i - 1].id];
        if(tmp[i].v != tmp[i - 1].v)
            A[tmp[i].id] ++;
    }
    for(int i = 1; i <= A[tmp[n].id]; ++ i){
        pos[i][1] = pos[i][2] = -1;
        pos[i][3] = 0;
    }
}

inline void INSERT(int u, int v){
    if(pos[A[u]][1] == -1) return;
    Insert(pos[A[u]][1] + 1, v);
    Insert(pos[A[u]][2] + 1, -v);
}

inline void updata(int u){
    pos[A[u]][1] = pos[A[u]][2];
    pos[A[u]][2] = pos[A[u]][3];
    pos[A[u]][3] = u;
}

int main(){
    Read(n); Read(m);
    for(int i = 1; i <= n; ++ i)
        Read(A[i]),
        tmp[i].v = A[i], tmp[i].id = i;
    int l, r;
    for(int i = 1; i <= m; ++ i){
        Read(l); Read(r);
        R[r].push_back(Question(i, l));
    }

    pre();

    int len;
    for(int i = 1; i <= n; ++ i){
        INSERT(i, -1);
        updata(i);
        INSERT(i, 1);
        len = R[i].size();
        for(int j = 0; j < len; ++ j)
            ans[R[i][j].id] = getsum(R[i][j].l);
    }
    for(int i = 1; i <= m; ++ i){
        printf("%d\n",ans[i]);
    }
    return 0;
}