[11.1]日常模拟.1

//QAQ我全打是二分，好像暴力就能过
//100 + 100 + 20（玄学）

##T1##
立方数(cubic)
Time Limit:1000ms Memory Limit:128MB
题目描述
LYK 定义了一个数叫“立方数”，若一个数可以被写作是一个正整数的 3 次方，则这个
数就是立方数，例如 1,8,27 就是最小的 3 个立方数。
现在给定一个数 P，LYK 想要知道这个数是不是立方数。
当然你有可能随机输出一些莫名其妙的东西来骗分，因此 LYK 有 T 次询问~
输入格式(cubic.in)
第一行一个数 T，表示有 T 组数据。
接下来 T 行，每行一个数 P。
输出格式(cubic.out)
输出 T 行，对于每个数如果是立方数，输出“YES”，否则输出“NO”。
输入样例
3
8
27
28
输出样例
YES
YES
NO
数据范围
对于 30%的数据 p<=100。
对于 60%的数据 p<=10^6。
对于 100%的数据 p<=10^18，T<=100。

就是暴力找 a[i]^3
然后二分找，lower_bound（）找也可以

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
#define ll long long

const int maxn = 1000000 + 100;
ll n, a[maxn];

ll read() {
	ll x = 0, f = 1;
	char ch = getchar();
	while(ch < '0' || ch > '9') {
		if(ch == '-') f = -1;
		ch = getchar();
	}
	while(ch >= '0' && ch <= '9') {
		x = (x << 1) + (x << 3) + ch - '0';
		ch = getchar();
	}
	return x * f;
}

int main() {
	freopen("cubic.in","r",stdin);
	freopen("cubic.out","w",stdout);
	n = read();
	for(int i = 1; i<= 1000000; i++) {
		a[i] = (ll)i * i * i;	
	}
	for(int i = 1; i <= n;i++) {
		int flag = 0;
		ll p = read();
		int r = 1, l = 1000000;
		while(r <= l) {
			int mid = (l + r) >> 1;
			if(a[mid] == p) {
				flag = 1;
				break;
			}
			else if(a[mid] > p) l = mid - 1;
			else r = mid + 1;
		}
		if(flag) puts("YES");
		else puts("NO");
	}
	return 0;
}

##T2##
立方数 2(cubicp)
Time Limit:1000ms Memory Limit:128MB
题目描述
LYK 定义了一个数叫“立方数”，若一个数可以被写作是一个正整数的 3 次方，则这个
数就是立方数，例如 1,8,27 就是最小的 3 个立方数。
LYK 还定义了一个数叫“立方差数”，若一个数可以被写作是两个立方数的差，则这个
数就是“立方差数”，例如 7(8-1),26(27-1),19(27-8)都是立方差数。
现在给定一个数 P，LYK 想要知道这个数是不是立方差数。
当然你有可能随机输出一些莫名其妙的东西，因此 LYK 有 T 次询问~
这个问题可能太难了…… 因此 LYK 规定 P 是个质数！
输入格式(cubicp.in)
第一行一个数 T，表示有 T 组数据。
接下来 T 行，每行一个数 P。
输出格式(cubicp.out)
输出 T 行，对于每个数如果是立方差数，输出“YES”，否则输出“NO”。
输入样例
5
2
3
5
7
11
输出样例
NO
NO
NO
YES
NO
数据范围
对于 30%的数据 p<=100。
对于 60%的数据 p<=10^6。
对于 100%的数据 p<=10^12，T<=100。

立方差公式
p = a^3 - b^3 = （a-b）*（a^2 + a *b +b^2);
因为p是素数，所以a-b，a^2 + a *b +b^2中肯定有个是1的
因为a^2 + a *b +b^2 ！= 1，所以a-b = 1
当a-b = 1时，a^2 + a *b +b^2 为素数（自己证）
筛一下就好了

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
#define ll long long

const int maxn = 1000000 + 100;
ll a[maxn];

ll read() {
	ll x = 0, f = 1;
	char ch = getchar();
	while(ch < '0' || ch > '9') {
		if(ch == '-') f = -1;
		ch = getchar();
	}
	while(ch >= '0' && ch <= '9') {
		x = (x << 1) + (x << 3) + ch - '0';
		ch = getchar();
	}
	return x * f;
}

int main() {
	freopen("cubicp.in","r",stdin);
	freopen("cubicp.out","w",stdout);
	ll n = read();
	for(int i = 0; i <= 600000; i++) {
		ll p = i, q = i + 1;
		a[i] = p * p + q * q + p * q;
	}
	for(int i = 1; i <= n;i++) {
		int flag = 0;
		ll p = read();
		int r = 0, l = 600000;
		while(r <= l) {
			int mid = (l + r) >> 1;
			if(a[mid] == p) {
				flag = 1;
				break;
			}
			else if(a[mid] > p) l = mid - 1;
			else r = mid + 1;
		}
		if(flag) puts("YES");
		else puts("NO");
	}
	return 0;
}

##T3##
猜数字(number)
Time Limit:2000ms Memory Limit:128MB
题目描述
LYK 在玩猜数字游戏。
总共有 n 个互不相同的正整数，LYK 每次猜一段区间的最小值。形如[li,ri]这段区间
的数字的最小值一定等于 xi。
我们总能构造出一种方案使得 LYK 满意。直到…… LYK 自己猜的就是矛盾的！
例如 LYK 猜[1,3]的最小值是 2，[1,4]的最小值是 3，这显然就是矛盾的。
你需要告诉 LYK，它第几次猜数字开始就已经矛盾了。
输入格式(number.in)
第一行两个数 n 和 T，表示有 n 个数字，LYK 猜了 T 次。
接下来 T 行，每行三个数分别表示 li,ri 和 xi。
输出格式(number.out)
输出一个数表示第几次开始出现矛盾，如果一直没出现矛盾输出 T+1。
输入样例
20 4
1 10 7
5 19 7
3 12 8
1 20 1
输出样例
3
数据范围
对于 50%的数据 n<=8，T<=10。
对于 80%的数据 n<=1000，T<=1000。
对于 100%的数据 1<=n,T<=1000000,1<=li<=ri<=n,1<=xi<=n （但并不保证一开始的所有数都
是 1~n 的）。

Hint
建议使用读入优化
inline int read()
{
int x = 0, f = 1;
char ch = getchar();
for(; !isdigit(ch); ch = getchar()) if(ch == '-') f = -1;
for(; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + ch - '0';
return x * f;
}

//看错题了打了个20分
//后来看不懂题解打了个暴力A了

由于每个区间只能知道它的最小值.现在要确定的就是怎么样才能判断一次猜测是不合法的.从题目给的样例可以看出，如果一个x较小的区间被x较大的区间给完全覆盖住了，那么这就是不合法的.根据这种判断方法，可以先对所有区间按照x从大到小排序，看这个区间有没有被之前的区间给覆盖.这就有一个问题：我不知道这个区间是第几次询问，那么二分第k次出现询问，把第一个到第k个区间排序就行了.

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define ll long long

const int maxn = 1000000 + 100;
int n,m,ans;
int f[maxn];

struct node{
    int l,r,w;
}p[maxn],e[maxn];

int read() {
    int x = 0, f = 1;
    char ch = getchar();
    while(ch < '0' || ch > '9') {
        if(ch == '-') f = -1;
        ch = getchar();
    }
    while(ch >= '0' && ch <= '9') {
        x = (x << 1) + (x << 3) + ch - '0';
        ch = getchar();
    }
    return x * f;
}

bool cmp(node a, node b) {
    return a.w > b.w;
}

bool pd(int mid) {
    memset(f,0,sizeof(f));
    for(int i = 1; i <= mid; i++) e[i] = p[i];
    sort(e+1,e+1+mid,cmp);
    int lmax = e[1].l, rmin = e[1].r, lmin = e[1].l, rmax = e[1].r;
    for(int i = 2; i <= mid; i++) {
        if(e[i].w < e[i-1].w) {
            int flag = 1;
            for(int j = lmax; j <= rmin; j++) {
                if(f[j] == 0) flag = 0;
            }
            for(int j = lmin; j <= rmax; j++) f[j] = 1;
            if(flag) return 1;
            lmin = lmax = e[i].l;
            rmin = rmax = e[i].r;
        }
        else {
            lmin = min(lmin, e[i].l);
            lmax = max(lmax, e[i].l);
            rmin = min(rmin, e[i].r);
            rmax = max(rmax, e[i].r);
            if(lmax > rmin) return 1;
        }
    }
    for(int i = lmax; i <= rmin; i++) if(f[i] == 0) return 0;
    return 1;
}

int main() {
	freopen("number.in","r",stdin);
  	freopen("number.out","w",stdout);
    n = read(), m = read();
    for(int i = 1; i <= m; i++) p[i].l = read(), p[i].r = read(), p[i].w = read();
    int l = 1, r = m, ans = m + 1;
    while(l <= r) {
        int mid = (r + l) >> 1;
        if(pd(mid)) {
            ans = mid;
            r = mid - 1;
        }
        else l = mid + 1;
    }
    cout<<ans;
    return 0;
}

std用的并查集维护的覆盖的点
定义f[i]表示i以后的第一个没有被覆盖的点
然后不断维护并查集，判断find（lmax）>rmin即可

#include <cstdio>
#include <iostream>
#include <algorithm>
#define N 1000011
#define min(x, y) ((x) < (y) ? (x) : (y))
#define max(x, y) ((x) > (y) ? (x) : (y))
using namespace std;
int n, q, ans;
int f[N];

struct node
{
	int x, y, z;
}p[N], t[N];

inline int read()
{
	int x = 0, f = 1;
	char ch = getchar();
	for(; !isdigit(ch); ch = getchar()) if(ch == '-') f = -1;
	for(; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + ch - '0';
	return x * f;
}

inline bool cmp(node x, node y)
{
	return x.z > y.z;
}

inline int find(int x)
{
	return x == f[x] ? x : f[x] = find(f[x]);
}

inline bool check(int k)
{
	int i, j, x, y, lmin, lmax, rmin, rmax;
	for(i = 1; i <= n + 1; i++) f[i] = i;
	for(i = 1; i <= k; i++) t[i] = p[i];
	std::sort(t + 1, t + k + 1, cmp);
	lmin = lmax = t[1].x;
	rmin = rmax = t[1].y;
	for(i = 2; i <= k; i++)
	{
		if(t[i].z < t[i - 1].z)
		{
			if(find(lmax) > rmin) return 1;
			for(j = find(lmin); j <= rmax; j++)
				f[find(j)] = find(rmax + 1);
			lmin = lmax = t[i].x;
			rmin = rmax = t[i].y;
		}
		else
		{
			lmin = min(lmin, t[i].x);
			lmax = max(lmax, t[i].x);
			rmin = min(rmin, t[i].y);
			rmax = max(rmax, t[i].y);
			if(lmax > rmin) return 1;
		}
	}
	if(find(lmax) > rmin) return 1;
	return 0;
}

int main()
{
    freopen("number.in","r",stdin);
    freopen("number.out","w",stdout);
	int i, x, y, mid;
	n = read();
	q = read();
	for(i = 1; i <= q; i++)
		p[i].x = read(), p[i].y = read(), p[i].z = read();
	x = 1, y = q;
	ans = q + 1;
	while(x <= y)
	{
		mid = (x + y) >> 1;
		if(check(mid)) ans = mid, y = mid - 1;
		else x = mid + 1;
	}
	printf("%d\n", ans);
	return 0;
}