[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;
}