Recentemente, Luba comprou um monitor. O monitor é uma matriz retangular de tamanho n × m. Mas então ela começou a notar que alguns pixels deixam de funcionar corretamente. Luba acha que o monitor se quebrará no primeiro momento em que contiver um quadrado k × k consistindo inteiramente de pixels quebrados. Ela sabe que q pixels já estão quebrados, e para cada um deles ela sabe o momento em que parou de funcionar. Ajude Luba a determinar quando o monitor quebrou (ou diga que ainda não está quebrado mesmo depois que todos os q pixels pararam de funcionar).
Entrada
A primeira linha contém quatro números inteiros n, m, k, q (1 ≤ n, m ≤ 500, 1 ≤ k ≤ min (n, m), 0 ≤ q ≤ n · m) - o comprimento e a largura do monitor, o tamanho de um retângulo de forma que o monitor seja quebrado se houver um retângulo quebrado com este tamanho e o número de pixels quebrados.
Cada uma das próximas q linhas contém três números inteiros xi, yi, ti (1 ≤ xi ≤ n, 1 ≤ yi ≤ m, 0 ≤ t ≤ 109) - coordenadas de i-ésimo pixel quebrado (sua linha e coluna na matriz) e no momento em que parou de funcionar. Cada pixel é listado no máximo uma vez.
Consideramos que o pixel já está quebrado no momento ti.
Saída
Imprimir um número - o momento mínimo em que o monitor quebrou, ou “-1” se ainda não quebrou depois que esses q pixels pararam de funcionar.
Exemplos
Entrada
2 3 2 5
2 1 8
2 2 8
1 2 1
1 3 4
2 3 2
Saída
8
Entrada
3 3 2 5
1 2 2
2 2 1
2 3 5
3 2 10
2 1 100
Saída
-1
Prefixo bidimensional e
significado:
Dada uma matriz n × m, q pontos nela são quebrados. Quando todos os pontos em uma submatriz k × k em toda a matriz são quebrados, então a matriz inteira está danificada. Os pontos q são danificados em uma certa ordem cronológica. É julgado o mais cedo quando toda a matriz será danificada, ou seja, os pontos nas submatrizes k × k estão todos danificados. Se não houver dano em toda a matriz, imprima -1.
Ideia para solução do problema:
Dado o tempo em que cada ponto é danificado, então o tempo é linear e monotônico, e o tempo de duas divisões pode ser usado para reduzir a complexidade do tempo.
Primeiro, classificamos os pontos q em ordem cronológica do menor para o maior e dividimos o tempo em dois. Para cada tempo médio, usamos uma matriz bidimensional mp para acumular todos os pontos danificados no tempo médio por 1 e, em seguida, adicionamos 1 para a matriz a Encontre a soma do prefixo novamente, em seguida, encontre a soma do prefixo na matriz a e, finalmente, enumere a submatriz k × k em todo o gráfico e consulte o número de pontos danificados na submatriz. número é igual a k × k, então mid é viável.
Código AC:
PS: Observe que o intervalo de dados de q é n * m
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<cctype>
#include<iomanip>
#include<map>
#include<vector>
#include<list>
#include<deque>
#include<stack>
#include<queue>
#include<set>
#include<cctype>
#include<string>
#include<stdexcept>
#include<fstream>
#define mem(a,b) memset(a,b,sizeof(a))
#define debug() puts("what the fuck!")
#define debug(a) cout<<#a<<"="<<a<<endl;
#define speed {
ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); };
#define ll long long
#define mod 998244353
using namespace std;
const double PI = acos(-1.0);
const int maxn = 5e2 + 10;
const int INF = 0x3f3f3f3f;
const double esp_0 = 1e-6;
ll gcd(ll x, ll y) {
return y ? gcd(y, x % y) : x;
}
ll lcm(ll x, ll y) {
return x * y / gcd(x, y);
}
ll extends_gcd(ll a, ll b, ll& x, ll& y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
ll gcdd=extends_gcd(b, a % b, x, y);
ll temp = x;
x = y;
y = temp - (a / b) * y;
return gcdd;
}
struct node {
int x, y, t;
friend bool operator<(const node& a, const node& b) {
return a.t < b.t;
}
}a[maxn * maxn];
int mp[maxn][maxn];
int sum[maxn][maxn];
int n, m, k, q;
int judge(int time) {
mem(mp, 0);
mem(sum, 0);
for (int i = 0; i < q; ++i) {
if (a[i].t <= time)mp[a[i].x][a[i].y] = 1;
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + mp[i][j];//求二维前缀和
}
}
for (int i = k; i <= n; ++i) {
for (int j = k; j <= m; ++j) {
//判断每一个k*k的子矩阵，注意下标是K
if (sum[i][j] - sum[i - k][j] - sum[i][j - k] + sum[i - k][j - k] == k * k) {
return 1;
}
}
}
return 0;
}
int main(){
scanf("%d%d%d%d", &n, &m, &k, &q);
int left = 0, right = 0, mid = 0;
for (int i = 0; i < q; ++i) {
scanf("%d%d%d", &a[i].x, &a[i].y, &a[i].t);
right = max(right, a[i].t);
}
sort(a, a + q);
int ans = INF;
while (left <= right) {
mid = (left + right) >> 1;
if (judge(mid)) {
ans = mid;
right = mid - 1;
}
else
left = mid + 1;
}
if (ans == INF) {
ans = -1;
}
printf("%d\n", ans);
return 0;
}