There is three topics
first is square
the topic is a (dfs)
we search the any point into any square
the 'in' function is to judge the point whether in the square(we had celect)
(we search the aim is point, so if the point over the 'n' we need return rather than over the 'm')
the code is follow
// square
#include <bits/stdc++.h>
using namespace std;
const int N = 66;
int n, m, ans = 2147483647;
struct node {int x, y;} a[N];
struct mtrx {int l, r, u, d; bool flag;} p[N];
inline int in (mtrx dy, int one, int two) {
if (dy.l <= one && dy.r >= one &&
dy.d <= two && dy.u >= two)
return true;
return false;
}
inline int pd (mtrx s, mtrx t) {
if (in(s, t.l, t.u)) return true;
if (in(s, t.l, t.d)) return true;
if (in(s, t.r, t.u)) return true;
if (in(s, t.r, t.d)) return true;
return false;
}
inline void dfs (int num) {
int nows(0);
for (int i = 1; i <= m; ++ i){
if (p[i].flag)
for (int j = i+1; j <= m; ++ j)
if (p[j].flag && pd(p[i], p[j]))
return;
nows += (p[i].r-p[i].l)*(p[i].u-p[i].d);
}
if (nows >= ans) return;
if (num > n) {
ans = nows;
return;
}
for (int i = 1; i <= m; ++ i) {
mtrx tmp = p[i];
if (p[i].flag == 0) {
p[i].flag = 1;
p[i].l = p[i].r = a[num].x;
p[i].u = p[i].d = a[num].y;
dfs (num+1);
p[i] = tmp;
} else {
p[i].l = min (p[i].l, a[num].x);
p[i].r = max (p[i].r, a[num].x);
p[i].u = max (p[i].u, a[num].y);
p[i].d = min (p[i].d, a[num].y);
dfs (num+1);
p[i] = tmp;
}
}
return;
}
main () {
cin >> n >> m;
for (int i = 1; i <= n; ++ i) cin >> a[i].x >> a[i].y;
dfs (1);
cout << ans;
return 0;
}
/*
4 2
1 1
2 2
3 6
0 7
*/
second is pat cows
1.sieve
2.violence
the code is follow
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5+10, N_y = 1e6+10;
int n, dx;
int a[N], v[N_y], ans[N_y];
int main () {
scanf ("%d", &n);
for (int i = 1; i <= n; ++ i) {
scanf ("%d", &a[i]);
++ v[a[i]];
dx = max (dx, a[i]);
}
for (int i = 1; i <= dx; ++ i) {
if (v[i])
for (int j = i; j <= dx; j += i)
ans[j] += v[i];
}
for (int i = 1; i <= n; ++ i) cout << ans[a[i]]-1 << '
';
return 0;
}
third is zip
PS:
1.pd function 'res' must zero
2.from l to r
We will have two happening
one is the block have the M
the other is don't have
we delimit the 'have M' is (f[i][j][1])
the other is (f[i][j][0])
the (f[i][j][0]) is more easy
before we to do state
we should list all of the state(double num). of coures we need pd
and then....
we find a 'k' to apply the epuation
the equation is
(f[i][j][0] = min(f[i][j][0], f[i][k][0]+j-k))
for the (f[i][j][1])
compared with the (f[i][j][0]) is more difficlt
we can make the all block (i->j) into two block i->k, and k->j
and the epuation is
(the first = min(f[i][k][1], f[i][k][0]))
(the second = min(f[k+1][j][1], f[k+1[j][0]))
(f[i][j][1] = min (f[i][j][1], thefirst + thesecond + 1))
(+ 1):because we must put a 'M' on the k
the code is follow
// zip
#include <bits/stdc++.h>
using namespace std;
const int N = 66;
int f[N][N][6];
char ch[N];
inline int pd (int s, int t) {
int k = (t-s+1), res(0), jz;
if (k&1) return false;
jz = (t+s+1)>>1; k >>=1;
for (int i = 0; i < k; ++ i)
if (ch[s+i] == ch[jz+i])
++ res;
return res == k;
}
main () {
scanf ("%s", ch+1);
int n = strlen(ch+1);
for (int i = 1; i <= n; ++ i)
for (int j = 1; j <= n; ++ j)
f[i][j][0] = f[i][j][1] = (j-i+1);
for (int len = 2; len <= n; ++ len) {
for (int i = 1; i <= n-len+1; ++ i) {
int j = i+len-1;
if (pd(i, j)) {
int m = (i+j)>>1;
f[i][j][0] = min (f[i][j][0], f[i][m][0]+1);
}
for (int k = 1; k <= j-1; ++ k)
f[i][j][0] = min (f[i][j][0], f[i][k][0]+j-k);
for (int k = 1; k <= j-1; ++ k)
f[i][j][1] = min (f[i][j][1],
min (f[i][k][0], f[i][k][1])+
min (f[k+1][j][0], f[k+1][j][1])+1);
}
}
cout << min (f[1][n][0], f[1][n][1]);
return 0;
}
(7.14update)
PS
1.pd funcition k or m must not '>>=1'
because if the num first is a even
after the '>>=1' the num maybe an odd
so we must before the '>>=1' to check the even or odd
2.initialization we must let the (i and j) 'for' from 1
3.when we search the 'k'
the 'k' is from 1 to j-1