KiritoTRw
GitHub
parent
c14ecbe72c
commit
661cb9622c
|
|
@ -0,0 +1,86 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
int t,n=7,m=8,num,dir[4][2]={-1,0,0,-1,0,1,1,0};
|
||||
int path[15],f[15];
|
||||
char map[15][15],p[]="ULRD",pathc[15];
|
||||
int ok(int x,int y)
|
||||
{
|
||||
if(x<0||y<0||x>=n||y>=m)
|
||||
return 0;
|
||||
return 1;
|
||||
}
|
||||
int dfs(int pos)
|
||||
{
|
||||
if(pos==num-1)
|
||||
return 1;
|
||||
int i,j,k,x,y,tx[15],ty[15];
|
||||
for(i=0;i<n;i++)
|
||||
for(j=0;j<m;j++)
|
||||
if(map[i][j]=='O')
|
||||
for(k=0;k<4;k++)
|
||||
{
|
||||
int flag=0,cnt=0;
|
||||
x=i+dir[k][0];
|
||||
y=j+dir[k][1];
|
||||
if(map[x][y]=='O')
|
||||
continue;
|
||||
while(ok(x,y))
|
||||
{
|
||||
if(map[x][y]=='O')
|
||||
{
|
||||
flag=1;
|
||||
tx[cnt]=x;
|
||||
ty[cnt++]=y;
|
||||
}
|
||||
x+=dir[k][0];
|
||||
y+=dir[k][1];
|
||||
}
|
||||
if(flag)
|
||||
{
|
||||
map[i][j]='X';
|
||||
for(int ii=0;ii<cnt;ii++)
|
||||
{
|
||||
map[tx[ii]][ty[ii]]='X';
|
||||
map[tx[ii]-dir[k][0]][ty[ii]-dir[k][1]]='O';
|
||||
}
|
||||
path[pos]=i*m+j;
|
||||
pathc[pos]=p[k];
|
||||
if(dfs(pos+1))
|
||||
return 1;
|
||||
map[i][j]='O';
|
||||
x=i+dir[k][0];
|
||||
y=j+dir[k][1];
|
||||
while(ok(x,y))
|
||||
{
|
||||
if(map[x][y]=='O')
|
||||
map[x][y]='X';
|
||||
x+=dir[k][0];
|
||||
y+=dir[k][1];
|
||||
}
|
||||
for(int ii=0;ii<cnt;ii++)
|
||||
map[tx[ii]][ty[ii]]='O';
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(~scanf("%s",map[0]))
|
||||
{
|
||||
int i,j;
|
||||
num=0;
|
||||
memset(f,0,sizeof(f));
|
||||
for(i=1;i<n;i++)
|
||||
scanf("%s",map[i]);
|
||||
for(i=0;i<n;i++)
|
||||
for(j=0;j<m;j++)
|
||||
if(map[i][j]=='O')
|
||||
num++;
|
||||
dfs(0);
|
||||
if(t)
|
||||
puts("");
|
||||
printf("CASE #%d:\n",++t);
|
||||
for(i=0;i<num-1;i++)
|
||||
printf("%d %d %c\n",path[i]/m,path[i]%m,pathc[i]);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
#include<cstdio>
|
||||
#include<cmath>
|
||||
#include<cstring>
|
||||
#include<queue>
|
||||
#include<vector>
|
||||
#include<ctime>
|
||||
#include<functional>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
typedef pair<int, int> PII;
|
||||
const int MX = 1e3 + 5;
|
||||
const int INF = 0x3f3f3f3f;
|
||||
const int mod = 1e9 + 7;
|
||||
LL eular(LL n) {
|
||||
LL ans = n;
|
||||
for(int i = 2; (LL)i * i <= n; i++) {
|
||||
if(n % i == 0) {
|
||||
ans -= ans / i;
|
||||
while(n % i == 0) n /= i;
|
||||
}
|
||||
}
|
||||
if(n > 1) ans -= ans / n;
|
||||
return ans;
|
||||
}
|
||||
int main() {
|
||||
LL n;
|
||||
while(~scanf("%I64dd", &n), n) {
|
||||
printf("%I64d\n", (n * (n - 1) / 2 - eular(n) * n / 2) % mod);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,113 @@
|
|||
#include <cstdio>
|
||||
#include <queue>
|
||||
#define INF 999999999
|
||||
#define max(A,B)(A>B?A:B)
|
||||
using namespace std;
|
||||
struct S{
|
||||
int x,y;
|
||||
}fruit[20],t;
|
||||
int n,m,cnt,ans,mp[256][256],dis[20][20],cost[256][256],nxt[4][2]={{1,0},{0,1},{-1,0},{0,-1}},mx[1<<18][20],val[20];
|
||||
void bfs(S t)
|
||||
{
|
||||
int i,j,nx,ny;
|
||||
for(i=0;i<n;i++) for(j=0;j<m;j++) cost[i][j]=INF;
|
||||
queue<S>que;
|
||||
cost[t.x][t.y]=0;
|
||||
que.push(t);
|
||||
while(!que.empty())
|
||||
{
|
||||
t=que.front();
|
||||
for(i=0;i<4;i++)
|
||||
{
|
||||
nx=t.x+nxt[i][0];
|
||||
ny=t.y+nxt[i][1];
|
||||
if(nx>=0 && nx<n && ny>=0 && ny<m && mp[nx][ny]!=-1 && cost[nx][ny]==INF)
|
||||
{
|
||||
cost[nx][ny]=cost[t.x][t.y]+1;
|
||||
t.x=nx;
|
||||
t.y=ny;
|
||||
que.push(t);
|
||||
}
|
||||
t=que.front();
|
||||
}
|
||||
que.pop();
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j;
|
||||
while(~scanf("%d%d",&n,&m))
|
||||
{
|
||||
cnt=0;
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
for(j=0;j<m;j++)
|
||||
{
|
||||
scanf("%d",&mp[i][j]);
|
||||
if(mp[i][j]>0)
|
||||
{
|
||||
fruit[cnt].x=i;
|
||||
fruit[cnt].y=j;
|
||||
val[cnt++]=mp[i][j];
|
||||
}
|
||||
}
|
||||
}
|
||||
if(n==1 && m==1)
|
||||
{
|
||||
if(mp[0][0]>=0) printf("%d\n",mp[0][0]);
|
||||
else printf("you loss!\n");
|
||||
continue;
|
||||
}
|
||||
if(mp[0][0]<=0)
|
||||
{
|
||||
printf("you loss!\n");
|
||||
continue;
|
||||
}
|
||||
if(mp[n-1][m-1]==-1)
|
||||
{
|
||||
printf("you loss!\n");
|
||||
continue;
|
||||
}
|
||||
fruit[cnt].x=n-1;
|
||||
fruit[cnt].y=m-1;
|
||||
for(i=0;i<=cnt;i++)
|
||||
{
|
||||
bfs(fruit[i]);
|
||||
for(j=0;j<=cnt;j++) dis[i][j]=cost[fruit[j].x][fruit[j].y];
|
||||
}
|
||||
queue<S>que;
|
||||
for(i=1;i<(1<<cnt);i++) for(j=0;j<cnt;j++) mx[i][j]=-1;
|
||||
int v;
|
||||
t.x=1;
|
||||
t.y=0;
|
||||
mx[t.x][t.y]=val[0];
|
||||
que.push(t);
|
||||
while(!que.empty())
|
||||
{
|
||||
t=que.front();
|
||||
for(i=1;i<cnt;i++)
|
||||
{
|
||||
if(!(t.x & (1<<i)))
|
||||
{
|
||||
v=mx[t.x][t.y]-dis[t.y][i];
|
||||
if(v>=0)
|
||||
{
|
||||
t.x=(t.x | (1<<i));
|
||||
t.y=i;
|
||||
if(v+val[i]>mx[t.x][i])
|
||||
{
|
||||
mx[t.x][i]=v+val[i];
|
||||
que.push(t);
|
||||
}
|
||||
t=que.front();
|
||||
}
|
||||
}
|
||||
}
|
||||
que.pop();
|
||||
}
|
||||
ans=-1;
|
||||
for(i=1;i<(1<<cnt);i++) for(j=0;j<cnt;j++) ans=max(ans,mx[i][j]-dis[j][cnt]);
|
||||
if(ans>=0) printf("%d\n",ans);
|
||||
else puts("you loss!");
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
#include <iostream>
|
||||
using namespace std;
|
||||
const __int64 Mod=100000007;
|
||||
__int64 mod_exp(__int64 a,__int64 b0,__int64 n=Mod)
|
||||
{
|
||||
if( a > n )
|
||||
a %= n;
|
||||
__int64 i, d = 1, b[35];
|
||||
for( i=0; i < 35; ++i )
|
||||
{
|
||||
b[i] = b0%2;
|
||||
b0 /= 2;
|
||||
if( b0 == 0 )
|
||||
break;
|
||||
}
|
||||
for( ;i >= 0; --i )
|
||||
{
|
||||
d = (d*d)%n;
|
||||
if( b[i] == 1 )
|
||||
d = (d*a)%n;
|
||||
}
|
||||
return d;
|
||||
}
|
||||
__int64 solve (__int64 n,__int64 m)
|
||||
{
|
||||
__int64 ans=1;
|
||||
for (__int64 i=m*n+2-n;i<m*n+1;i++)
|
||||
{
|
||||
ans=((((ans*i)%Mod)*mod_exp(i-m*n+n-1,Mod-2)))%Mod;
|
||||
}
|
||||
ans=(ans*mod_exp(n,Mod-2))%Mod;
|
||||
return ans;
|
||||
}
|
||||
int main ()
|
||||
{
|
||||
__int64 n,m;
|
||||
while (scanf ("%I64d%I64d",&n,&m)!=EOF)
|
||||
{
|
||||
printf ("%I64d\n",solve(n,m));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,93 @@
|
|||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <ctype.h>
|
||||
#include <math.h>
|
||||
#include <stack>
|
||||
#include <queue>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define ll __int64
|
||||
#define ls rt<<1
|
||||
#define rs ls|1
|
||||
#define lson l,mid,ls
|
||||
#define rson mid+1,r,rs
|
||||
#define middle (l+r)>>1
|
||||
#define clr_all(x,c) memset(x,c,sizeof(x))
|
||||
#define clr(x,c,n) memset(x,c,sizeof(x[0])*(n+1))
|
||||
#define eps (1e-8)
|
||||
#define MOD 1000000007
|
||||
#define INF 0x3f3f3f3f
|
||||
#define PI (acos(-1.0))
|
||||
#pragma comment(linker, "/STACK:102400000,102400000")
|
||||
template <class T> T _max(T x,T y){return x>y? x:y;}
|
||||
template <class T> T _min(T x,T y){return x<y? x:y;}
|
||||
template <class T> T _abs(T x){return (x < 0)? -x:x;}
|
||||
template <class T> T _mod(T x,T y){return (x > 0)? x%y:((x%y)+y)%y;}
|
||||
template <class T> void _swap(T &x,T &y){T t=x;x=y;y=t;}
|
||||
template <class T> void getmax(T& x,T y){x=(y > x)? y:x;}
|
||||
template <class T> void getmin(T& x,T y){x=(x<0 || y<x)? y:x;}
|
||||
int TS,cas=1;
|
||||
const int M=500+5;
|
||||
int n;
|
||||
string str,ret;
|
||||
bool cmp(char a,char b){
|
||||
return a > b;
|
||||
}
|
||||
bool vis[M];
|
||||
bool check(char c,int i){
|
||||
return ret[i-1]!=c && (i+1==ret.length()||ret[i+1]!=c);
|
||||
}
|
||||
void run(){
|
||||
int i,j;
|
||||
cin>>str;
|
||||
sort(str.begin(),str.end(),cmp);
|
||||
clr_all(vis,0);
|
||||
ret.clear();
|
||||
ret+=str[0],vis[0]=1;
|
||||
for(i=1,j=1;i<str.length();i++) if(!vis[i]){
|
||||
if(str[i]!=ret[ret.length()-1]) ret+=str[i],vis[i]=1;
|
||||
else{
|
||||
for(j=i+1;j<str.length();j++) if(!vis[j]){
|
||||
if(str[j]!=ret[ret.length()-1]){
|
||||
ret+=str[j],ret+=str[i];
|
||||
vis[i]=vis[j]=1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(j==str.length()){
|
||||
for(;i<str.length();i++) if(!vis[i]){
|
||||
for(j=ret.length()-1;j>=0;j--){
|
||||
if(str[i]!=ret[j] && (j==0 || str[i]!=ret[j-1])){
|
||||
ret.insert(j,1,str[i]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(j<0) break;
|
||||
}
|
||||
for(i=0;i<ret.length();i++){
|
||||
for(j=i+1;j<ret.length();j++){
|
||||
if(ret[i]<ret[j] && check(ret[i],j) && check(ret[j],i)){
|
||||
_swap(ret[i],ret[j]);
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
//cout<<ret<<endl;
|
||||
}
|
||||
cout<<ret<<endl;
|
||||
}
|
||||
void preSof(){
|
||||
}
|
||||
int main(){
|
||||
preSof();
|
||||
for(scanf("%d",&TS);cas<=TS;cas++) run();
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,147 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define MAXN 160
|
||||
const int N = MAXN * 2 + 2, E = MAXN * 2 + MAXN * MAXN;
|
||||
typedef long long typec;
|
||||
const typec inf = 0x3f3f3f3f3f3f3f3fLL;
|
||||
struct NetWork {
|
||||
int _n, _ne, _head[N], _cur[N], _ps[N], _dep[N];
|
||||
typec _cost;
|
||||
struct Edge {
|
||||
int _x, _y, _next;
|
||||
typec _c;
|
||||
} _bf[E * 2 + 2];
|
||||
void add_edge(int x, int y, typec c) {
|
||||
_bf[_ne]._x = x; _bf[_ne]._y = y; _bf[_ne]._c = c;
|
||||
_bf[_ne]._next = _head[x]; _head[x] = _ne++;
|
||||
_bf[_ne]._x = y; _bf[_ne]._y = x; _bf[_ne]._c = 0;
|
||||
_bf[_ne]._next = _head[y]; _head[y] = _ne++;
|
||||
}
|
||||
inline void build(int n) {
|
||||
_n = n; _ne = 2;
|
||||
memset(_head, 0, n * sizeof (int));
|
||||
}
|
||||
typec max_flow(int s, int t) {
|
||||
typec tr, res = 0;
|
||||
int i, j, k, f, r, top;
|
||||
while (1) {
|
||||
memset(_dep, -1, _n * sizeof (int));
|
||||
for (f = _dep[_ps[0] = s] = 0, r = 1; f != r;)
|
||||
for (i = _ps[f++], j = _head[i]; j; j = _bf[j]._next) {
|
||||
if (_bf[j]._c && -1 == _dep[k = _bf[j]._y]) {
|
||||
_dep[k] = _dep[i] + 1;
|
||||
_ps[r++] = k;
|
||||
if (k == t) {
|
||||
f = r;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (-1 == _dep[t]) break;
|
||||
memcpy(_cur, _head, _n * sizeof (int));
|
||||
for (i = s, top = 0;;) {
|
||||
if (i == t) {
|
||||
for (k = 0, tr = inf; k < top; ++k)
|
||||
if (_bf[_ps[k]]._c < tr)
|
||||
tr = _bf[_ps[f = k]]._c;
|
||||
for (k = 0; k < top; ++k)
|
||||
_bf[_ps[k]]._c -= tr, _bf[_ps[k]^1]._c += tr;
|
||||
res += tr;
|
||||
i = _bf[_ps[top = f]]._x;
|
||||
}
|
||||
for (j = _cur[i]; _cur[i]; j = _cur[i] = _bf[_cur[i]]._next)
|
||||
if (_bf[j]._c && _dep[i] + 1 == _dep[_bf[j]._y]) break;
|
||||
if (_cur[i]) {
|
||||
_ps[top++] = _cur[i];
|
||||
i = _bf[_cur[i]]._y;
|
||||
} else {
|
||||
if (0 == top) break;
|
||||
_dep[i] = -1;
|
||||
i = _bf[_ps[--top]]._x;
|
||||
}
|
||||
}
|
||||
}
|
||||
return _cost = res;
|
||||
}
|
||||
} g;
|
||||
int n, m;
|
||||
long long love[MAXN], hate[MAXN];
|
||||
struct Trie {
|
||||
Trie* next[26];
|
||||
int terminate;
|
||||
} nodes[MAXN * 600], *ptr;
|
||||
void insert_trie(char* s, int no) {
|
||||
Trie* root = nodes;
|
||||
for (int i = 0; s[i]; ++i) {
|
||||
if (root->next[s[i] - 'a'] == 0) {
|
||||
root->next[s[i] - 'a'] = ++ptr;
|
||||
memset(ptr, 0, sizeof(Trie));
|
||||
ptr->terminate = -1;
|
||||
}
|
||||
root = root->next[s[i] - 'a'];
|
||||
}
|
||||
if (root->terminate != -1) {
|
||||
love[no] += love[root->terminate];
|
||||
hate[no] += hate[root->terminate];
|
||||
}
|
||||
root->terminate = no;
|
||||
}
|
||||
long long slove[MAXN];
|
||||
bool map[MAXN][MAXN];
|
||||
void find_trie(char* s, int noo) {
|
||||
Trie* root = nodes;
|
||||
for (int i = 0; s[i]; ++i)
|
||||
if (root->next[s[i] - 'a']) {
|
||||
root = root->next[s[i] - 'a'];
|
||||
if (root->terminate != -1) {
|
||||
slove[noo] += love[root->terminate];
|
||||
map[noo][root->terminate] = true;
|
||||
}
|
||||
} else
|
||||
return;
|
||||
}
|
||||
inline int pointS(int x) {
|
||||
return x;
|
||||
}
|
||||
inline int pointP(int x) {
|
||||
return n + x;
|
||||
}
|
||||
char buf[20000];
|
||||
int main() {
|
||||
int test;
|
||||
scanf("%d", &test);
|
||||
for (int cas = 1; cas <= test; ++cas) {
|
||||
memset(slove, 0, sizeof(slove));
|
||||
memset(map, 0, sizeof(map));
|
||||
ptr = nodes;
|
||||
memset(ptr, 0, sizeof(Trie));
|
||||
scanf("%d%d", &n, &m);
|
||||
for (int i = 0; i < n; ++i) {
|
||||
scanf("%I64d%I64d%s", love + i, hate + i, buf);
|
||||
insert_trie(buf, i);
|
||||
}
|
||||
for (int i = 0; i < m; ++i) {
|
||||
scanf("%s", buf);
|
||||
int len = strlen(buf);
|
||||
for (int j = 0; j < len; ++j)
|
||||
find_trie(buf + j, i);
|
||||
}
|
||||
g.build(n + m + 2);
|
||||
int src = n + m, sink = n + m + 1;
|
||||
for (int i = 0; i < n; ++i)
|
||||
g.add_edge(pointS(i), sink, hate[i]);
|
||||
long long sum = 0;
|
||||
for (int i = 0; i < m; ++i) {
|
||||
g.add_edge(src, pointP(i), slove[i]);
|
||||
sum += slove[i];
|
||||
}
|
||||
for (int i = 0; i < n; ++i)
|
||||
for (int j = 0; j < m; ++j)
|
||||
if (map[j][i])
|
||||
g.add_edge(pointP(j), pointS(i), inf);
|
||||
printf("Case %d: %I64d\n", cas, sum - g.max_flow(src, sink));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,56 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
using namespace std;
|
||||
const int maxx=2002;
|
||||
int dp[maxx][maxx],mark[maxx][maxx],sum[maxx][maxx];
|
||||
int data[maxx];
|
||||
int min(int a,int b){
|
||||
return a<b?a:b;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
while (scanf("%d",&n)!=EOF)
|
||||
{
|
||||
for (int i=1;i<=n;i++)
|
||||
{
|
||||
scanf("%d",&data[i]);
|
||||
data[i+n]=data[i];
|
||||
}
|
||||
memset(sum,0,sizeof(sum));
|
||||
for (int i=1;i<2*n;i++)
|
||||
{
|
||||
dp[i][i]=0;
|
||||
mark[i][i]=i;
|
||||
for (int j=i;j<=n+i;j++)
|
||||
{
|
||||
sum[i][j]=sum[i][j-1]+data[j];
|
||||
}
|
||||
}
|
||||
for (int st=2;st<=n;st++)
|
||||
{
|
||||
for (int i=1;i+st<=2*n+1;i++)
|
||||
{
|
||||
int j=i+st-1;
|
||||
dp[i][j]=99999999;
|
||||
for (int k=mark[i][j-1];k<=mark[i+1][j];k++)
|
||||
{
|
||||
int temp=dp[i][k]+dp[k+1][j]+sum[i][j];
|
||||
if (dp[i][j]>temp)
|
||||
{
|
||||
dp[i][j]=temp;
|
||||
mark[i][j]=k;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int ans=9999999;
|
||||
for (int i=1;i<=n;i++)
|
||||
{
|
||||
ans=min(ans,dp[i][i+n-1]);
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
#include<stdio.h>
|
||||
#include<iostream>
|
||||
#include<string.h>
|
||||
#include<queue>
|
||||
using namespace std;
|
||||
const int MAXN=500010;
|
||||
int dp[MAXN];
|
||||
int q[MAXN];
|
||||
int sum[MAXN];
|
||||
int head,tail,n,m;
|
||||
int getDP(int i,int j)
|
||||
{
|
||||
return dp[j]+m+(sum[i]-sum[j])*(sum[i]-sum[j]);
|
||||
}
|
||||
int getUP(int j,int k)
|
||||
{
|
||||
return dp[j]+sum[j]*sum[j]-(dp[k]+sum[k]*sum[k]);
|
||||
}
|
||||
int getDOWN(int j,int k)
|
||||
{
|
||||
return 2*(sum[j]-sum[k]);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d%d",&n,&m)==2)
|
||||
{
|
||||
for(int i=1;i<=n;i++)
|
||||
scanf("%d",&sum[i]);
|
||||
sum[0]=dp[0]=0;
|
||||
for(int i=1;i<=n;i++)
|
||||
sum[i]+=sum[i-1];
|
||||
head=tail=0;
|
||||
q[tail++]=0;
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
while(head+1<tail && getUP(q[head+1],q[head])<=sum[i]*getDOWN(q[head+1],q[head]))
|
||||
head++;
|
||||
dp[i]=getDP(i,q[head]);
|
||||
while(head+1<tail && getUP(i,q[tail-1])*getDOWN(q[tail-1],q[tail-2])<=getUP(q[tail-1],q[tail-2])*getDOWN(i,q[tail-1]))
|
||||
tail--;
|
||||
q[tail++]=i;
|
||||
}
|
||||
printf("%d\n",dp[n]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
using namespace std;
|
||||
int vis[40100];
|
||||
int q[12000];
|
||||
int main()
|
||||
{memset(vis,1,sizeof(vis));
|
||||
vis[1]=0;
|
||||
int t=0;
|
||||
for(int i=2;i<=40000;i++)
|
||||
{if(vis[i])
|
||||
{for(int j=i;j<=40000;j+=i)
|
||||
vis[j]=0;
|
||||
q[++t]=i;
|
||||
}
|
||||
}
|
||||
long long int shu[100],ge[100];
|
||||
long long int n;
|
||||
while(cin>>n)
|
||||
{if(n==1){cout<<"0"<<endl; continue;}
|
||||
if(n==4){cout<<3<<endl; continue;}
|
||||
long long int m=1,k=0;
|
||||
long long int tt=n;
|
||||
memset(shu,0,sizeof(shu));
|
||||
memset(ge,0,sizeof(ge));
|
||||
while(tt>1&&m<t)
|
||||
{if(tt%q[m]==0)
|
||||
shu[++k]=q[m];
|
||||
if(k>=3)break;
|
||||
while(tt%q[m]==0)
|
||||
{tt/=q[m];
|
||||
ge[k]++;
|
||||
}
|
||||
m++;
|
||||
}
|
||||
if(tt>1)
|
||||
{shu[++k]=tt;
|
||||
ge[k]++;
|
||||
}
|
||||
if(k>=3) {cout<<1<<endl; continue;}
|
||||
if(k==1)
|
||||
{if(shu[1]!=2)
|
||||
cout<<(n-1)<<endl;
|
||||
else cout<<1<<endl;
|
||||
}
|
||||
if(k==2)
|
||||
{if(shu[1]==2 && ge[1]==1)
|
||||
cout<<n-1<<endl;
|
||||
else cout<<1<<endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,71 @@
|
|||
#include <cstdio>
|
||||
#include <iostream>
|
||||
#include <cstring>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
const int N=55;
|
||||
LL x[N][N],y[N][N],s[N][N];
|
||||
LL A[N],B[N],F1[N],F2[N],tmp;
|
||||
int f1,f2,a,b,K,n,m;
|
||||
int i,j,k,t;
|
||||
void mul(LL x[N][N],LL y[N][N])
|
||||
{
|
||||
int i,j,k;
|
||||
for(i=0; i<K+2; ++i)
|
||||
{
|
||||
for(j=0; j<K+2; ++j)
|
||||
{
|
||||
for(s[i][j]=k=0; k<K+2; ++k)
|
||||
s[i][j]+=x[i][k]*y[k][j]%m;
|
||||
s[i][j]%=m;
|
||||
}
|
||||
}
|
||||
for(i=0; i<K+2; ++i)
|
||||
for(j=0; j<K+2; ++j)
|
||||
x[i][j]=s[i][j];
|
||||
}
|
||||
int main()
|
||||
{
|
||||
cin>>t;
|
||||
while(t--)
|
||||
{
|
||||
cin>>f1>>f2>>a>>b>>K>>n>>m;
|
||||
A[0]=B[0]=F1[0]=F2[0]=1;
|
||||
for(i=1; i<K+2; ++i)
|
||||
{
|
||||
A[i]=A[i-1]*a%m;
|
||||
B[i]=B[i-1]*b%m;
|
||||
F1[i]=F1[i-1]*f1%m;
|
||||
F2[i]=F2[i-1]*f2%m;
|
||||
}
|
||||
memset(x,0,sizeof(x));
|
||||
memset(y,0,sizeof(y));
|
||||
for(i=0; i<K+2; ++i)x[i][i]=1;
|
||||
y[0][0]=y[0][1]=1;
|
||||
for(i=1; i<K+2; ++i)
|
||||
{
|
||||
for(j=1,tmp=1,k=K-i+2; k--; ++j)
|
||||
{
|
||||
y[i][j]=(tmp%m)*A[k]%m;
|
||||
y[i][j]=(y[i][j]*B[j-1])%m;
|
||||
tmp*=k;
|
||||
tmp/=j;
|
||||
}
|
||||
}
|
||||
--n;
|
||||
while(n)
|
||||
{
|
||||
if(n&1)mul(x,y);
|
||||
mul(y,y);
|
||||
n>>=1;
|
||||
}
|
||||
tmp=F1[K]*x[0][0]%m;
|
||||
for(i=1; i<K+2; ++i)
|
||||
{
|
||||
tmp+=((F2[K-i+1]*F1[i-1])%m)*x[0][i];
|
||||
tmp%=m;
|
||||
}
|
||||
cout<<tmp<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,74 @@
|
|||
#include <cstdio>
|
||||
#include <deque>
|
||||
#include <set>
|
||||
#include <string>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
#include <cstring>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <queue>
|
||||
#include <stack>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
template<class T> inline T& RD(T &x){
|
||||
char c; for (c = getchar(); c < '0'; c = getchar()); x = c - '0'; for (c = getchar(); '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
|
||||
return x;
|
||||
}
|
||||
const int inf = 0x3f3f3f3f;
|
||||
const int maxn = 100005;
|
||||
int ra[maxn];
|
||||
int d[maxn];
|
||||
int fa[maxn];
|
||||
vector<int> v[maxn];
|
||||
int dfs(int u){
|
||||
ra[u] = 0;
|
||||
for(int i=0;i<v[u].size();i++){
|
||||
ra[u]= max(dfs(v[u][i])+1,ra[u]);
|
||||
}
|
||||
return ra[u];
|
||||
}
|
||||
int main(){
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
while(T --){
|
||||
int n,e,m;
|
||||
scanf("%d%d%d",&n,&e,&m);
|
||||
memset(ra,0,sizeof(ra));
|
||||
memset(d,0,sizeof(d));
|
||||
memset(fa,0,sizeof(fa));
|
||||
for(int i=1;i<=n;i++)v[i].clear();
|
||||
for(int i=0;i<e;i++){
|
||||
int a,b;
|
||||
scanf("%d%d",&a,&b);
|
||||
v[b].push_back(a);
|
||||
fa[a] = 1;
|
||||
}
|
||||
for(int i=1;i<=n;i++){
|
||||
if(fa[i] == 0)dfs(i);
|
||||
}
|
||||
int _max = 0;
|
||||
for(int i=1;i<=n;i++){
|
||||
d[ra[i]] ++;
|
||||
_max = max(_max,ra[i]);
|
||||
}
|
||||
int cnt = 0,lft = 0;
|
||||
for(int i=0;i<=_max;i++){
|
||||
int td = d[i];
|
||||
if(cnt > i){
|
||||
d[i] -= lft;
|
||||
if(d[i] < 0){
|
||||
lft -= td;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
cnt += d[i]/m;
|
||||
if(d[i]%m)cnt ++;
|
||||
lft = m - d[i]%m;
|
||||
if(lft == m)lft = 0;
|
||||
}
|
||||
printf("%d\n", cnt);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,111 @@
|
|||
#include <set>
|
||||
#include <queue>
|
||||
#include <stack>
|
||||
#include <math.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <iostream>
|
||||
#include <limits.h>
|
||||
#include <string.h>
|
||||
#include <string>
|
||||
#include <algorithm>
|
||||
#define MID(x,y) ( ( x + y ) >> 1 )
|
||||
#define L(x) ( x << 1 )
|
||||
#define R(x) ( x << 1 | 1 )
|
||||
#define BUG puts("here!!!")
|
||||
using namespace std;
|
||||
const int MAX = 100010;
|
||||
int X;
|
||||
struct circle{ int w,x,y,r;};
|
||||
circle c[MAX];
|
||||
double yy(int id,int flag)
|
||||
{
|
||||
double d = sqrt(c[id].r*1.0*c[id].r - (X-c[id].x)*1.0*(X-c[id].x));
|
||||
if( flag == 1 ) return c[id].y + d;
|
||||
return c[id].y - d;
|
||||
}
|
||||
struct Sline{
|
||||
int flag,id;
|
||||
bool operator<(const Sline a)const
|
||||
{
|
||||
double y1 = yy(id, flag);
|
||||
double y2 = yy(a.id, a.flag);
|
||||
return y1 > y2 || y1 == y2 && flag > a.flag;
|
||||
}
|
||||
};
|
||||
set<Sline> s;
|
||||
set<Sline>::iterator pre,suc,it;
|
||||
struct event{ int x,id,flag;};
|
||||
event l[MAX];
|
||||
bool cmp(event a,event b)
|
||||
{
|
||||
if( a.x == b.x )
|
||||
return c[a.id].y > c[b.id].y;
|
||||
return a.x < b.x;
|
||||
}
|
||||
void add_line(circle c, int &cnt ,int id)
|
||||
{
|
||||
l[cnt].id = id;
|
||||
l[cnt].x = c.x - c.r;
|
||||
l[cnt++].flag = 1;
|
||||
l[cnt].id = id;
|
||||
l[cnt].x = c.x + c.r;
|
||||
l[cnt++].flag = -1;
|
||||
}
|
||||
void solve(int n)
|
||||
{
|
||||
s.clear();
|
||||
Sline node;
|
||||
for(int i=0; i<n; i++)
|
||||
{
|
||||
X = l[i].x;
|
||||
if( l[i].flag == 1 )
|
||||
{
|
||||
node.id = l[i].id; node.flag = 1;
|
||||
it = s.insert(node).first;
|
||||
suc = pre = it;
|
||||
suc++;
|
||||
if( it == s.begin() || suc == s.end() )
|
||||
c[it->id].w = 1;
|
||||
else
|
||||
{
|
||||
pre--;
|
||||
if( pre->id == suc->id )
|
||||
c[it->id].w = c[pre->id].w + 1;
|
||||
else
|
||||
c[it->id].w = max( c[pre->id].w, c[suc->id].w);
|
||||
}
|
||||
node.flag = -1;
|
||||
s.insert(node);
|
||||
}
|
||||
else
|
||||
{
|
||||
node.id = l[i].id; node.flag = 1;
|
||||
s.erase(node);
|
||||
node.flag = -1;
|
||||
s.erase(node);
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int ncases,n;
|
||||
int x1,x2,y1,y2,xx,yy,r;
|
||||
while( ~scanf("%d",&n) )
|
||||
{
|
||||
int cnt = 0;
|
||||
for(int i=0; i<n; i++)
|
||||
{
|
||||
scanf("%d%d%d",&c[i].x, &c[i].y, &c[i].r);
|
||||
c[i].w = 0;
|
||||
add_line(c[i],cnt,i);
|
||||
}
|
||||
sort(l,l+cnt,cmp);
|
||||
solve(cnt);
|
||||
int ans = 0;
|
||||
for(int i=0; i<n; i++)
|
||||
ans = max(ans, c[i].w);
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
const int MAXN = 100010;
|
||||
const long long INF = 1LL<<62;
|
||||
int A[MAXN],B[MAXN];
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
while(~scanf("%d",&n))
|
||||
{
|
||||
for(int i=0;i<n;i++)
|
||||
scanf("%d",&A[i]);
|
||||
for(int i=0;i<n;i++)
|
||||
scanf("%d",&B[i]);
|
||||
sort(A,A+n);
|
||||
sort(B,B+n);
|
||||
long long ans=-INF;
|
||||
int ka=lower_bound(A,A+n,0)-A;
|
||||
int kb=lower_bound(B,B+n,0)-B;
|
||||
int d1=min(n-ka,kb);
|
||||
int a1=n-1,b1=d1-1;
|
||||
for(int cnt=0;cnt<d1;cnt++)
|
||||
{
|
||||
ans=max(ans,(long long)A[a1--]*B[b1--]);
|
||||
}
|
||||
int d2=min(ka,n-kb);
|
||||
int a2=d2-1,b2=n-1;
|
||||
for(int cnt=0;cnt<d2;cnt++)
|
||||
{
|
||||
ans=max(ans,(long long)A[a2--]*B[b2--]);
|
||||
}
|
||||
a1=n-1-d1,b1=d1;
|
||||
for(int cnt=0;cnt<n-d1-d2;cnt++)
|
||||
{
|
||||
ans=max(ans,(long long)A[a1--]*B[b1++]);
|
||||
}
|
||||
printf("%I64d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,116 @@
|
|||
#include <map>
|
||||
#include <set>
|
||||
#include <list>
|
||||
#include <cmath>
|
||||
#include <ctime>
|
||||
#include <queue>
|
||||
#include <stack>
|
||||
#include <bitset>
|
||||
#include <cstdio>
|
||||
#include <vector>
|
||||
#include <cassert>
|
||||
#include <climits>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <sstream>
|
||||
#include <iomanip>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <functional>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
typedef pair<int, int> PII;
|
||||
#define MP(a, b) make_pair(a, b)
|
||||
#define FOREACH(e,x) for(__typeof(x.begin()) e=x.begin();e!=x.end();++e)
|
||||
const int MAX_R = 30 + 1;
|
||||
const int dir[5][2] = {{0, 0}, {0, -1}, {0, 1}, {-1, 0}, {1, 0}};
|
||||
int R, C;
|
||||
int dp[MAX_R][MAX_R][MAX_R][MAX_R], vis[MAX_R][MAX_R];
|
||||
char mat[MAX_R][MAX_R];
|
||||
int valid(int r, int c) {
|
||||
return r >= 0 && r < R && c >= 0 && c < C && mat[r][c] != '#';
|
||||
}
|
||||
int searchQ(int qr, int qc, int ar, int ac) {
|
||||
int &ret = dp[qr][qc][ar][ac];
|
||||
if (ret != -1)
|
||||
return ret;
|
||||
if (qr == ar && qc == ac)
|
||||
return ret = 0;
|
||||
if (mat[qr][qc] == 'E')
|
||||
return ret = 1;
|
||||
ret = 0;
|
||||
int nqr, nqc, nar, nac;
|
||||
for (int i = 1; i < 5 && !ret; i++) {
|
||||
nqr = qr + dir[i][0];
|
||||
nqc = qc + dir[i][1];
|
||||
if (!valid(nqr, nqc) || vis[nqr][nqc]) continue;
|
||||
if (nqr == ar && nqc == ac)
|
||||
continue;
|
||||
vis[nqr][nqc] = 1;
|
||||
int win = 1;
|
||||
for (int j = 0; j < 5 && win; j++) {
|
||||
nar = ar + dir[j][0];
|
||||
nac = ac + dir[j][1];
|
||||
if (!valid(nar, nac)) continue;
|
||||
win &= searchQ(nqr, nqc, nar, nac);
|
||||
}
|
||||
vis[nqr][nqc] = 0;
|
||||
ret |= win;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
int searchA(int qr, int qc, int ar, int ac) {
|
||||
int &ret = dp[qr][qc][ar][ac];
|
||||
if (ret != -1)
|
||||
return ret;
|
||||
if (qr == ar && qc == ac)
|
||||
return ret = 1;
|
||||
if (mat[qr][qc] == 'E')
|
||||
return ret = 0;
|
||||
ret = 0;
|
||||
int nqr, nqc, nar, nac;
|
||||
for (int i = 1; i < 5 && !ret; i++) {
|
||||
nar = ar + dir[i][0];
|
||||
nac = ac + dir[i][1];
|
||||
if (!valid(nar, nac) || vis[nar][nac]) continue;
|
||||
vis[nar][nac] = 1;
|
||||
int win = 1;
|
||||
for (int j = 0; j < 5 && win; j++) {
|
||||
nqr = qr + dir[j][0];
|
||||
nqc = qc + dir[j][1];
|
||||
if (!valid(nqr, nqc)) continue;
|
||||
if (nqr == ar && nqc == ac)
|
||||
continue;
|
||||
win &= searchA(nqr, nqc, nar, nac);
|
||||
}
|
||||
vis[nar][nac] = 0;
|
||||
ret |= win;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
int main() {
|
||||
while (~scanf("%d %d", &C, &R)) {
|
||||
int sQr, sQc, sAr, sAc;
|
||||
for (int r = 0; r < R; r++) {
|
||||
scanf("%s", mat[r]);
|
||||
for (int c = 0; c < C; c++) {
|
||||
if (mat[r][c] == 'Q') sQr = r, sQc = c;
|
||||
if (mat[r][c] == 'A') sAr = r, sAc = c;
|
||||
}
|
||||
}
|
||||
memset(dp, -1, sizeof(dp));
|
||||
memset(vis, 0, sizeof(vis));
|
||||
vis[sQr][sQc] = 1;
|
||||
int escape = searchQ(sQr, sQc, sAr, sAc);
|
||||
if (escape) puts("Queen can escape.");
|
||||
else {
|
||||
memset(dp, -1, sizeof(dp));
|
||||
memset(vis, 0, sizeof(vis));
|
||||
vis[sAr][sAc] = 1;
|
||||
int cath = searchA(sQr, sQc, sAr, sAc);
|
||||
if (!cath) puts("Queen can not escape and Army can not catch Queen.");
|
||||
else puts("Army can catch Queen.");
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,55 @@
|
|||
#include<cstdio>
|
||||
#include<cmath>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
const double eps = 1e-9;
|
||||
const double Pi = acos(-1.0);
|
||||
double ls[110];
|
||||
int n;
|
||||
inline double f(double s){
|
||||
double ret = 0.0, a, b;
|
||||
int i;
|
||||
for(i = 0; i < n; ++i)
|
||||
{
|
||||
a = ls[i];
|
||||
b = ls[(i+1) % n];
|
||||
ret += acos((a*a+b*b - s*s) / (2.0 * a *b));
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
int main(){
|
||||
int i, T, temp;
|
||||
double as[110], h, s, at[110], ang, l, r, m;
|
||||
scanf("%d", &T);
|
||||
while(T--){
|
||||
scanf("%d%lf%lf", &n, &s, &h);
|
||||
for(i = 0; i < n; ++i){
|
||||
scanf("%lf", &at[i]);
|
||||
at[i] *= Pi / 180.0;
|
||||
}
|
||||
sort(at, at + n);
|
||||
for((temp=0, i = 0); i < n; i+=2){
|
||||
as[temp++] = at[i];
|
||||
}
|
||||
--i;
|
||||
i >= n ? i-=2 : 1;
|
||||
for(; i >= 0; i-=2)
|
||||
as[temp++] = at[i];
|
||||
for(i = 0; i < n; ++i)
|
||||
ls[i] = 1.0 / tan(as[i]);
|
||||
l = 0.0;
|
||||
r = 1e20;
|
||||
for(i = 0;i < n; ++i){
|
||||
ls[i] + ls[(i+1) % n] < r ? r = ls[i] + ls[(i+1)%n] : 1;
|
||||
fabs(ls[i]-ls[(i+1)%n]) > l ? l = fabs(ls[i] - ls[(i+1)%n] ):1;
|
||||
}
|
||||
l += eps;
|
||||
r -= eps;
|
||||
while(r-l > eps){
|
||||
m = (l + r) * 0.5;
|
||||
f(m) < 2.0 * Pi ? l = m : r = m;
|
||||
}
|
||||
printf("%.4lf\n", s/m + h *0.01);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,45 @@
|
|||
#include <iostream>
|
||||
using namespace std;
|
||||
#define M 1005
|
||||
#define INF 1000000000
|
||||
int n,f[M][M],sum[M][M],s[M][M];
|
||||
struct POINTS
|
||||
{
|
||||
int x,y;
|
||||
}stone[M];
|
||||
int dis(POINTS a,POINTS b,POINTS c,POINTS d)//calculate from a to d; b,c is division point
|
||||
{
|
||||
return abs(c.x-a.x)+abs(d.y-b.y);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j,k,t;
|
||||
while(cin>>n)
|
||||
{
|
||||
for(i=1;i<=n;i++)
|
||||
scanf("%d%d",&stone[i].x,&stone[i].y);
|
||||
memset(f,0,sizeof(f));
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
s[i][i]=i;
|
||||
}
|
||||
for(int len=2;len<=n;len++)
|
||||
{
|
||||
for(i=1;i<=n-len+1;i++)
|
||||
{
|
||||
j=i+len-1;
|
||||
f[i][j]=INF;
|
||||
for(k=s[i][j-1];k<=s[i+1][j];k++)
|
||||
{
|
||||
if(f[i][j]>f[i][k]+f[k+1][j]+dis(stone[i],stone[k],stone[k+1],stone[j]))
|
||||
{
|
||||
f[i][j]=f[i][k]+f[k+1][j]+dis(stone[i],stone[k],stone[k+1],stone[j]);
|
||||
s[i][j]=k;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("%d\n",f[1][n]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,215 @@
|
|||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <cstdio>
|
||||
using namespace std;
|
||||
#define maxn MAXN
|
||||
const int MAXN = 508;
|
||||
int G[MAXN][MAXN];
|
||||
int mx[maxn],my[maxn];
|
||||
int used[MAXN];
|
||||
int ansX[maxn],ansY[maxn];
|
||||
int delX,delY;
|
||||
struct per
|
||||
{
|
||||
int dislike[maxn];
|
||||
int like;
|
||||
int dp;
|
||||
};
|
||||
per person[maxn];
|
||||
int X[maxn],Y[maxn];
|
||||
int nx,ny;
|
||||
int shuchu[maxn];
|
||||
int shuchu2[maxn];
|
||||
#define clr(x) memset(x,0,sizeof(int)*MAXN)
|
||||
#define _clr(x) memset(x,0xff,sizeof(int)*MAXN)
|
||||
int hungray(int m,int n,int mat[][maxn],int *match1,int *match2)
|
||||
{
|
||||
int s[maxn],t[maxn],p,q,ret=0,i,j,k;
|
||||
for(_clr(match1),_clr(match2),i=0;i<m;ret+=(match1[i++]>=0))
|
||||
for(_clr(t),s[p=q=0]=i;p<=q&&match1[i]<0;p++)
|
||||
for(k=s[p],j=0;j<n&&match1[i]<0;j++)
|
||||
if(mat[k][j]&&t[j]<0)
|
||||
{
|
||||
s[++q]=match2[j],t[j]=k;
|
||||
if(s[q]<0)
|
||||
for(p=j;p>=0;j=p)
|
||||
match2[j]=k=t[j],p=match1[k],match1[k]=j;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
bool Find(int v)
|
||||
{
|
||||
for(int u=0;u<ny;u++)
|
||||
{
|
||||
if(!used[u]&&G[v][u])
|
||||
{
|
||||
used[u]=1;
|
||||
if(my[u]==-1||Find(my[u]))
|
||||
{
|
||||
mx[v]=u;my[u]=v; return 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
bool FindY(int v)
|
||||
{
|
||||
for(int u=0;u<ny;u++)
|
||||
{
|
||||
if(u!=delY&&!used[u]&&G[v][u])
|
||||
{
|
||||
used[u]=1;
|
||||
if(my[u]==-1||FindY(my[u]))
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
bool FindX(int u)
|
||||
{
|
||||
for(int v=0;v<nx;v++)
|
||||
{ if(v!=delX&&!used[v]&&G[v][u])
|
||||
{
|
||||
used[v]=1;
|
||||
if(mx[v]==-1||FindX(mx[v]))
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
int MMG()
|
||||
{
|
||||
for(int i=0;i<nx;i++)mx[i]=-1;
|
||||
for(int j=0;j<ny;j++)my[j]=-1;
|
||||
int sum=0;
|
||||
for(int i=0;i<nx;i++)
|
||||
{
|
||||
clr(used);
|
||||
if(Find(i))
|
||||
sum++;
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
void Work()
|
||||
{
|
||||
printf("%d\n",nx+ny-MMG());
|
||||
clr(ansX);
|
||||
clr(ansY);
|
||||
for(int i=0;i<nx;i++)
|
||||
{ if(mx[i]==-1)
|
||||
{
|
||||
ansX[i]=1;
|
||||
}
|
||||
else
|
||||
{
|
||||
delY=mx[i];
|
||||
clr(used);
|
||||
if(FindY(i))ansY[delY]=1;
|
||||
}
|
||||
}
|
||||
for(int j=0;j<ny;j++)
|
||||
{
|
||||
if(my[j]==-1)
|
||||
ansY[j]=1;
|
||||
else
|
||||
{
|
||||
delX=my[j];
|
||||
clr(used);
|
||||
if(FindX(j))ansX[delX]=1;
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
int a,b,p;
|
||||
scanf("%d%d%d",&a,&b,&p);
|
||||
memset(G,0,sizeof(G));
|
||||
memset(person,0,sizeof(person));
|
||||
clr(shuchu2);
|
||||
clr(shuchu);
|
||||
int like,num;
|
||||
nx=0,ny=0;
|
||||
for(int i=0;i<p;i++)
|
||||
{
|
||||
scanf("%d",&like);
|
||||
if(like>a)
|
||||
{
|
||||
X[nx++]=i;
|
||||
}
|
||||
else
|
||||
{
|
||||
Y[ny++]=i;
|
||||
}
|
||||
person[i].like=like;
|
||||
scanf("%d",&person[i].dp);
|
||||
for(int j=0;j<person[i].dp;j++)
|
||||
scanf("%d",&person[i].dislike[j]);
|
||||
}
|
||||
for(int i=0;i<nx;i++)
|
||||
{
|
||||
for(int j=0;j<ny;j++)
|
||||
{
|
||||
for(int t=0;t<person[Y[j]].dp;t++)
|
||||
{
|
||||
if(person[X[i]].like==person[Y[j]].dislike[t])
|
||||
{
|
||||
G[i][j]=1;break;
|
||||
}
|
||||
}
|
||||
if(G[i][j]==0)
|
||||
for(int t=0;t<person[X[i]].dp;t++)
|
||||
{
|
||||
if(person[Y[j]].like==person[X[i]].dislike[t])
|
||||
{
|
||||
G[i][j]=1;break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Work();
|
||||
int ipsc=0;
|
||||
for(int t=0;t<nx;t++)
|
||||
{
|
||||
if(ansX[t]==1)
|
||||
{
|
||||
shuchu[ipsc++]=person[X[t]].like;
|
||||
}
|
||||
}
|
||||
for(int t=0;t<ny;t++)
|
||||
{
|
||||
if(ansY[t]==1)
|
||||
{
|
||||
shuchu[ipsc++]=person[Y[t]].like;
|
||||
}
|
||||
}
|
||||
sort(shuchu,shuchu+ipsc);
|
||||
int ipsc2=0;
|
||||
if(ipsc>0)
|
||||
{
|
||||
shuchu2[ipsc2++]=shuchu[0];
|
||||
}
|
||||
for(int t=1;t<ipsc;t++)
|
||||
{
|
||||
if(shuchu[t]!=shuchu[t-1])
|
||||
{
|
||||
shuchu2[ipsc2++]=shuchu[t];
|
||||
}
|
||||
}
|
||||
printf("%d",ipsc2);
|
||||
for(int t=0;t<ipsc2;t++)
|
||||
{
|
||||
printf(" %d",shuchu2[t]);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,80 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#define max 11000
|
||||
int wa[max],wb[max],wv[max],ws[max];
|
||||
int rank[max],height[max];
|
||||
int cmp(int *r,int a,int b,int l)
|
||||
{
|
||||
return r[a]==r[b]&&r[a+l]==r[b+l];
|
||||
}
|
||||
void da(int *r,int *sa,int n,int m)
|
||||
{
|
||||
int i,j,p,*x=wa,*y=wb,*t;
|
||||
for(i=0; i<m; i++) ws[i]=0;
|
||||
for(i=0; i<n; i++) ws[x[i]=r[i]]++;
|
||||
for(i=1; i<m; i++) ws[i]+=ws[i-1];
|
||||
for(i=n-1; i>=0; i--) sa[--ws[x[i]]]=i;
|
||||
for(p=1,j=1; p<n; j*=2,m=p)
|
||||
{
|
||||
for(p=0,i=n-j; i<n; i++) y[p++]=i;
|
||||
for(i=0; i<n; i++) if(sa[i]>=j) y[p++]=sa[i]-j;
|
||||
for(i=0; i<n; i++) wv[i]=x[y[i]];
|
||||
for(i=0; i<m; i++) ws[i]=0;
|
||||
for(i=0; i<n; i++) ws[wv[i]]++;
|
||||
for(i=1; i<m; i++) ws[i]+=ws[i-1];
|
||||
for(i=n-1; i>=0; i--) sa[--ws[wv[i]]]=y[i];
|
||||
for(t=x,x=y,y=t,p=1,x[sa[0]]=0,i=1; i<n; i++)
|
||||
x[sa[i]]=cmp(y,sa[i-1],sa[i],j)?p-1:p++;
|
||||
}
|
||||
return ;
|
||||
}
|
||||
void calheight(int *r,int *sa,int n)
|
||||
{
|
||||
int i,j,k=0;
|
||||
for(i=1; i<=n; i++)rank[sa[i]]=i;
|
||||
for(i=0; i<n; height[rank[i++]]=k)
|
||||
for(k?k--:0,j=sa[rank[i]-1]; r[i+k]==r[j+k]; k++);
|
||||
return;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
char str1[max];
|
||||
int str[max];
|
||||
int sa[max];
|
||||
int mint;
|
||||
int maxt;
|
||||
while(scanf("%s",str1)!=EOF)
|
||||
{
|
||||
int len=strlen(str1);
|
||||
if(str1[0]=='#')
|
||||
break;
|
||||
for(int i=0;i<len;i++)
|
||||
str[i]=str1[i]-'a'+1;
|
||||
str[len]=0;
|
||||
da(str,sa,len+1,27);
|
||||
calheight(str,sa,len);
|
||||
int ans=0;
|
||||
for(int i=1; i<=(len+1)/2; i++)
|
||||
{
|
||||
mint=1001;
|
||||
maxt=-1;
|
||||
for(int j=1; j<=len; j++)
|
||||
{
|
||||
if(height[j]>=i)
|
||||
{
|
||||
int tem=sa[j-1]>sa[j]?sa[j]:sa[j-1];
|
||||
mint=mint>tem?tem:mint;
|
||||
tem=sa[j-1]>sa[j]?sa[j-1]:sa[j];
|
||||
maxt=maxt>tem?maxt:tem; }
|
||||
else
|
||||
{
|
||||
if(mint+i<=maxt)ans++;
|
||||
mint=1001,maxt=-1;
|
||||
}
|
||||
}
|
||||
if(mint+i<=maxt)ans++;
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<string>
|
||||
#include<iostream>
|
||||
#include<cmath>
|
||||
#include<algorithm>
|
||||
#include<queue>
|
||||
#include<stack>
|
||||
#include<map>
|
||||
#define LG long long
|
||||
using namespace std;
|
||||
const int maxn=10005,MAX=1<<30,MIN=-(1<<30);
|
||||
struct node
|
||||
{
|
||||
int gp[5][5];
|
||||
}A,B;
|
||||
int n,m;
|
||||
node mul(node a,node b)
|
||||
{
|
||||
node c;
|
||||
for(int i=0;i<4;i++)
|
||||
for(int j=0;j<4;j++)
|
||||
{
|
||||
c.gp[i][j]=0;
|
||||
for(int k=0;k<4;k++)
|
||||
{
|
||||
c.gp[i][j]+=a.gp[i][k]*b.gp[k][j];
|
||||
c.gp[i][j]%=m;
|
||||
}
|
||||
}
|
||||
return c;
|
||||
}
|
||||
node sort_exp(int k)
|
||||
{
|
||||
node ans=B,a=A;
|
||||
while(k)
|
||||
{
|
||||
if(k&1)ans=mul(ans,a);
|
||||
k>>=1;
|
||||
a=mul(a,a);
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
for(int i=0;i<2;i++)
|
||||
B.gp[i][i]=1;
|
||||
memset(A.gp,0,sizeof(A.gp));
|
||||
A.gp[0][0]=A.gp[0][1]=A.gp[1][0]=A.gp[1][2]=A.gp[2][3]=1;
|
||||
A.gp[3][3]=2;
|
||||
m=10007;
|
||||
while(~scanf("%d",&n))
|
||||
{
|
||||
node ans=sort_exp(n);
|
||||
printf("%d\n",2*ans.gp[0][3]%m);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,205 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<cmath>
|
||||
#include<vector>
|
||||
#include<algorithm>
|
||||
#define eps 1e-8
|
||||
#define inf 999999999
|
||||
#define N 10100
|
||||
#define pi acos(-1.0)
|
||||
using namespace std;
|
||||
int Sig(double a)
|
||||
{
|
||||
return a<-eps?-1:a>eps;
|
||||
}
|
||||
struct Point
|
||||
{
|
||||
double x,y;
|
||||
Point(){}
|
||||
Point(double x0,double y0):x(x0),y(y0){}
|
||||
void in()
|
||||
{
|
||||
scanf("%lf%lf",&x,&y);
|
||||
}
|
||||
double len()
|
||||
{
|
||||
return sqrt(x*x+y*y);
|
||||
}
|
||||
double operator ^(Point pt)
|
||||
{
|
||||
return pt.x*x+pt.y*y;
|
||||
}
|
||||
Point operator -(Point pt)
|
||||
{
|
||||
return Point(x-pt.x,y-pt.y);
|
||||
}
|
||||
Point operator +(Point pt)
|
||||
{
|
||||
return Point(x+pt.x,y+pt.y);
|
||||
}
|
||||
Point operator *(double t)
|
||||
{
|
||||
return Point(x*t,y*t);
|
||||
}
|
||||
Point operator /(double t)
|
||||
{
|
||||
return Point(x/t,y/t);
|
||||
}
|
||||
};
|
||||
struct Polygon
|
||||
{
|
||||
Point p[220];
|
||||
int n;
|
||||
void in()
|
||||
{
|
||||
for(int i=0;i<n;i++)
|
||||
p[i].in();
|
||||
}
|
||||
};
|
||||
double Xmult(Point o,Point a,Point b)
|
||||
{
|
||||
return (a.x-o.x)*(b.y-o.y)-(b.x-o.x)*(a.y-o.y);
|
||||
}
|
||||
double Dis(Point a,Point b)
|
||||
{
|
||||
return (a-b).len();
|
||||
}
|
||||
int con[300];
|
||||
int cn;//铆1掳眉渭Ķ锟ノã锚y
|
||||
Point po;
|
||||
int cmp(Point a,Point b)
|
||||
{
|
||||
double d=Xmult(po,a,b);
|
||||
if(d>0)
|
||||
return 1;
|
||||
if(d==0 && Dis(a,po)<Dis(b,po))
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
void Graham(Point p[],int &n)
|
||||
{
|
||||
int i,ind=0;
|
||||
for(i=1;i<n;i++)
|
||||
if(p[ind].y>p[i].y || (p[ind].y==p[i].y && p[ind].x>p[i].x))
|
||||
ind=i;
|
||||
swap(p[ind],p[0]);
|
||||
po=p[0];
|
||||
sort(p+1,p+n,cmp);
|
||||
con[0]=0;
|
||||
con[1]=1;
|
||||
cn=1;
|
||||
for(i=2;i<n;i++)
|
||||
{
|
||||
while(cn>0 && Sig(Xmult(p[con[cn-1]],p[con[cn]],p[i]))<=0)
|
||||
cn--;
|
||||
con[++cn]=i;
|
||||
}
|
||||
int tmp=cn;
|
||||
for(i=n-2;i>=0;i--)
|
||||
{
|
||||
while(cn>tmp && Sig(Xmult(p[con[cn-1]],p[con[cn]],p[i]))<=0)
|
||||
cn--;
|
||||
con[++cn]=i;//p[cn]==p[0];
|
||||
}
|
||||
Point pt[210];
|
||||
for(int i=0;i<cn;i++)
|
||||
pt[i]=p[con[i]];
|
||||
for(int i=0;i<cn;i++)
|
||||
p[i]=pt[i];
|
||||
n=cn;
|
||||
}
|
||||
Point Intersection(Point u1,Point u2,Point v1,Point v2)
|
||||
{
|
||||
Point ret=u1;
|
||||
double t=((u1.x-v1.x)*(v1.y-v2.y)-(u1.y-v1.y)*(v1.x-v2.x))/
|
||||
((u1.x-u2.x)*(v1.y-v2.y)-(u1.y-u2.y)*(v1.x-v2.x));
|
||||
ret.x+=(u2.x-u1.x)*t;
|
||||
ret.y+=(u2.y-u1.y)*t;
|
||||
return ret;
|
||||
}
|
||||
double Area(Point p[],int n)
|
||||
{
|
||||
double s=0;
|
||||
for(int i=0;i<n;i++)
|
||||
s+=Xmult(Point(0,0),p[i],p[(i+1)%n]);
|
||||
return fabs(s)*0.5;
|
||||
}
|
||||
double Get_inter(Polygon p1,Polygon p2)
|
||||
{
|
||||
Polygon tmp,newp;
|
||||
newp=p2;
|
||||
for(int i=0;i<p1.n;i++)
|
||||
{
|
||||
Point a=p1.p[i];
|
||||
Point b=p1.p[(i+1)%p1.n];
|
||||
tmp.n=0;
|
||||
for(int j=0;j<newp.n;j++)
|
||||
{
|
||||
int r1=Sig(Xmult(a,b,newp.p[j]));
|
||||
int r2=Sig(Xmult(a,b,newp.p[(j+1)%newp.n]));
|
||||
if(r1>=0)
|
||||
tmp.p[tmp.n++]=newp.p[j];
|
||||
if(r1*r2<0)
|
||||
{
|
||||
Point pp=Intersection(a,b,newp.p[j],newp.p[(j+1)%newp.n]);
|
||||
tmp.p[tmp.n++]=pp;
|
||||
}
|
||||
}
|
||||
newp=tmp;
|
||||
}
|
||||
return Area(newp.p,newp.n);
|
||||
}
|
||||
double Work(Polygon p1,Polygon p2,Point v,double ks,double all)
|
||||
{
|
||||
Polygon tmp;
|
||||
double left=0,right=inf;
|
||||
double mid;
|
||||
while(right-left>eps)
|
||||
{
|
||||
mid=(left+right)*0.5;
|
||||
tmp=p1;
|
||||
for(int i=0;i<tmp.n;i++)
|
||||
tmp.p[tmp.n+i]=tmp.p[i]+v*mid;
|
||||
tmp.n*=2;
|
||||
Graham(tmp.p,tmp.n);
|
||||
double s=Get_inter(tmp,p2);
|
||||
if(Sig(all-s-ks)<=0)
|
||||
right=mid-eps;
|
||||
else
|
||||
left=mid+eps;
|
||||
}
|
||||
return left;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
Polygon p1,p2;
|
||||
Point v;
|
||||
double k,ange;
|
||||
while(scanf("%d",&p2.n)!=EOF)
|
||||
{
|
||||
p2.in();
|
||||
scanf("%d",&p1.n);
|
||||
p1.in();
|
||||
scanf("%lf%lf",&ange,&k);
|
||||
ange=ange/360*2*pi;
|
||||
v=Point(cos(ange),sin(ange));
|
||||
v=v/v.len();
|
||||
double s=Area(p2.p,p2.n);
|
||||
Polygon tmp=p1;
|
||||
for(int i=0;i<tmp.n;i++)
|
||||
{
|
||||
tmp.p[tmp.n+i]=tmp.p[i]+v*inf;
|
||||
}
|
||||
tmp.n*=2;
|
||||
Graham(tmp.p,tmp.n);
|
||||
double s1=s-Get_inter(p1,p2);
|
||||
double s2=s-Get_inter(tmp,p2);
|
||||
if(Sig(s1-s*k)<0 || Sig(s2-s*k)>0)
|
||||
{
|
||||
printf("-1\n");
|
||||
continue;
|
||||
}
|
||||
printf("%.4f\n",Work(p1,p2,v,k*s,s));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,68 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<iostream>
|
||||
using namespace std;
|
||||
const int M=150;
|
||||
double matrix[M][M],ans[M][M],matrix1[M][M];
|
||||
int n,m;
|
||||
void mulmatrix(int p)
|
||||
{
|
||||
int i,j,k;
|
||||
double c[M][M];
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
for(j=1;j<=n;j++)
|
||||
{
|
||||
c[i][j]=0;
|
||||
for(k=1;k<=n;k++)
|
||||
c[i][j]+=matrix1[i][k]*matrix[k][j];
|
||||
}
|
||||
}
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
for(j=1;j<=n;j++)
|
||||
matrix1[i][j]=c[i][j]/(p*1.0);
|
||||
}
|
||||
}
|
||||
void addmatrix()
|
||||
{
|
||||
int i,j;
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
for(j=1;j<=n;j++)
|
||||
ans[i][j]+=matrix1[i][j];
|
||||
}
|
||||
}
|
||||
void read()
|
||||
{
|
||||
int i,j;
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
for(j=1;j<=n;j++)
|
||||
printf("%.2lf ",ans[i][j]);
|
||||
printf("\n");
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d",&n),n)
|
||||
{
|
||||
int i,j,k;
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
for(j=1;j<=n;j++)
|
||||
{
|
||||
scanf("%lf",&matrix[i][j]);
|
||||
if(i==j) {ans[i][j]=matrix1[i][j]=1.0;}
|
||||
else {ans[i][j]=matrix1[i][j]=0;}
|
||||
}
|
||||
}
|
||||
for(k=1;k<50;k++)
|
||||
{
|
||||
mulmatrix(k);
|
||||
addmatrix();
|
||||
}
|
||||
read();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
void exkmp(char s1[],char s2[],int next[],int ex[]) {
|
||||
int i,j,p;
|
||||
for (i=0,j=0,p=-1;s1[i]!='\0';i++,j++,p--) {
|
||||
if (p==-1) {
|
||||
j=0;
|
||||
do p++; while (s1[i+p]!='\0'&&s1[i+p]==s2[j+p]);
|
||||
ex[i]=p;
|
||||
} else if (next[j]<p) ex[i]=next[j];
|
||||
else if (next[j]>p) ex[i]=p;
|
||||
else {
|
||||
j=0;
|
||||
while (s1[i+p]!='\0'&&s1[i+p]==s2[j+p]) p++;
|
||||
ex[i]=p;
|
||||
}
|
||||
}
|
||||
ex[i]=0;
|
||||
}
|
||||
char s1[100100];
|
||||
char s2[100100];
|
||||
int ex[100100];
|
||||
int next[100100];
|
||||
int ls1,ls2;
|
||||
bool smallerThan(int i,int j) {
|
||||
if (ex[j]<i-j) return s1[j+ex[j]]<s2[ex[j]];
|
||||
if (next[i-j]<ls2-(i-j)) return s2[next[i-j]]<s2[i-j+next[i-j]];
|
||||
if (next[ls2-(i-j)]<(i-j)) return s2[ls2-(i-j)+next[ls2-(i-j)]]<s2[next[ls2-(i-j)]];
|
||||
return false;
|
||||
}
|
||||
int main() {
|
||||
int ans,i;
|
||||
while (scanf("%s%s",s1,s2)!=EOF) {
|
||||
exkmp(s2+1,s2,next,next+1);
|
||||
exkmp(s1,s2,next,ex);
|
||||
ls1=strlen(s1);
|
||||
ls2=strlen(s2);
|
||||
ans=0;
|
||||
for (i=0;i<ls1;i++) {
|
||||
if (smallerThan(i+1,ans)) ans=i+1;
|
||||
}
|
||||
for (i=0;i<ans;i++) printf("%c",s1[i]);
|
||||
printf("%s",s2);
|
||||
for (i=ans;i<ls1;i++) printf("%c",s1[i]);
|
||||
printf("\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,118 @@
|
|||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <climits>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
#include<iostream>
|
||||
#include<queue>
|
||||
#include <map>
|
||||
using namespace std;
|
||||
typedef long long ll;
|
||||
#define INF (INT_MAX/10)
|
||||
#define SQR(x) ((x)*(x))
|
||||
#define rep(i, n) for (int i=0; i<(n); ++i)
|
||||
#define repf(i, a, b) for (int i=(a); i<=(b); ++i)
|
||||
#define repd(i, a, b) for (int i=(a); i>=(b); --i)
|
||||
#define clr(ar,val) memset(ar, val, sizeof(ar))
|
||||
#define inf 1000000000
|
||||
#define N 205
|
||||
class match{
|
||||
public:
|
||||
int lx[N],ly[N];
|
||||
int Stack[N],next[N];
|
||||
bool visx[N],visy[N];
|
||||
int n;
|
||||
vector<int>vec[N];
|
||||
void init()
|
||||
{
|
||||
rep(i,n+1) vec[i].clear();
|
||||
memset(next,-1,sizeof(next));
|
||||
}
|
||||
bool bfs(int u)
|
||||
{
|
||||
visx[u]=true;
|
||||
rep(i,vec[u].size())
|
||||
{
|
||||
if(visy[i]==true) continue;
|
||||
if(lx[u]+ly[i]==vec[u][i])
|
||||
{
|
||||
visy[i]=true;
|
||||
if(next[i]==-1 || bfs(next[i]))
|
||||
{
|
||||
next[i]=u; return true;
|
||||
}
|
||||
}
|
||||
else
|
||||
Stack[i]=min(Stack[i],lx[u]+ly[i]-vec[u][i]);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
int km()
|
||||
{
|
||||
rep(i,n) lx[i]=-inf;
|
||||
rep(i,n)
|
||||
{
|
||||
ly[i]=0;
|
||||
rep(j,n)
|
||||
lx[i]=max(lx[i],vec[i][j]);
|
||||
}
|
||||
rep(i,n)
|
||||
{
|
||||
while(true)
|
||||
{
|
||||
memset(visx,false,sizeof(visx));
|
||||
memset(visy,false,sizeof(visy));
|
||||
rep(j,n) Stack[j]=inf;
|
||||
if(bfs(i)) break;
|
||||
int Min=inf;
|
||||
rep(j,n)
|
||||
if(visy[j]==false)
|
||||
Min=min(Min,Stack[j]);
|
||||
rep(j,n)
|
||||
{
|
||||
if(visx[j]==true) lx[j]-=Min;
|
||||
if(visy[j]==true) ly[j]+=Min;
|
||||
}
|
||||
}
|
||||
}
|
||||
int ans=0;
|
||||
rep(i,n)
|
||||
ans+=vec[next[i]][i];
|
||||
return ans;
|
||||
}
|
||||
};
|
||||
match sa;
|
||||
int n,m;
|
||||
int a[N][N];
|
||||
void solve()
|
||||
{
|
||||
scanf("%d%d",&n,&m);
|
||||
rep(i,m)
|
||||
rep(j,n)
|
||||
scanf("%d",&a[i][j]),--a[i][j];
|
||||
sa.n=n;
|
||||
sa.init();
|
||||
rep(i,n)
|
||||
{
|
||||
rep(j,n)
|
||||
{
|
||||
int sum=0;
|
||||
rep(k,m)
|
||||
sum+=-abs(j-a[k][i]);
|
||||
sa.vec[i].push_back(sum);
|
||||
}
|
||||
}
|
||||
printf("%d\n",-sa.km());
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int test;
|
||||
scanf("%d",&test);
|
||||
repf(ror,1,test)
|
||||
{
|
||||
printf("Case #%d: ",ror);
|
||||
solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,57 @@
|
|||
#include <cstdio>
|
||||
#include <cmath>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#define mod 10007
|
||||
int Pow(int a,int b)
|
||||
{
|
||||
int ans=1;
|
||||
while(b)
|
||||
{
|
||||
if(b&1)
|
||||
{
|
||||
b--;
|
||||
ans*=a;
|
||||
ans%=(3*mod);
|
||||
}
|
||||
else
|
||||
{
|
||||
b/=2;
|
||||
a*=a;
|
||||
a%=(3*mod);
|
||||
}
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int solve(int n)
|
||||
{
|
||||
if(n&1)
|
||||
{
|
||||
n++;
|
||||
n/=2;
|
||||
int ans=Pow(4,n-1);
|
||||
ans+=5;
|
||||
ans/=3;
|
||||
return ans%mod;
|
||||
}
|
||||
else
|
||||
{
|
||||
n/=2;
|
||||
int ans=2*Pow(4,n-1);
|
||||
ans+=4;
|
||||
ans/=3;
|
||||
return ans%mod;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t;
|
||||
scanf("%d",&t);
|
||||
for(int i=1;i<=t;i++)
|
||||
{
|
||||
int n;
|
||||
scanf("%d",&n);
|
||||
printf("Case #%d: %d\n",i,solve(n));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,127 @@
|
|||
#include <iostream>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
using namespace std;
|
||||
const int maxn=20001,maxm=maxn*100;
|
||||
inline int Max(int a,int b){return a>b?a:b;}
|
||||
int a[maxm],b[maxm];
|
||||
int f[maxn][20],ff[maxn];
|
||||
int ne[maxm];
|
||||
int tree[maxm];
|
||||
int lowbit(int t)
|
||||
{
|
||||
return t&-t;
|
||||
}
|
||||
int ask(int k)
|
||||
{
|
||||
int res=0;
|
||||
while (k)
|
||||
{
|
||||
res=Max(res,tree[k]);
|
||||
k-=lowbit(k);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
void change(int k,int d,int n)
|
||||
{
|
||||
while (k<=n)
|
||||
{
|
||||
tree[k]=Max(tree[k],d);
|
||||
k+=lowbit(k);
|
||||
}
|
||||
}
|
||||
int n,m;
|
||||
char buf[2048576],*o;
|
||||
int getint() {
|
||||
while (!isdigit(*o)) o++;
|
||||
int f = 0;
|
||||
while (isdigit(*o)) f=f*10+*o-'0',o++;
|
||||
return f;
|
||||
}
|
||||
void iin()
|
||||
{
|
||||
int i,j,k,col,pos;
|
||||
scanf("%d%d\n",&n,&m);
|
||||
for (i=0;i<=n*m*2+10;i++)
|
||||
{
|
||||
ne[i]=i+1;
|
||||
a[i]=0;
|
||||
}
|
||||
for (i=0;i<n*m;i++)
|
||||
{
|
||||
scanf("%d%d",&col,&pos);
|
||||
k=pos;
|
||||
while (a[k]!=0) k=ne[k];
|
||||
a[k]=col;
|
||||
j=k;
|
||||
k=pos;
|
||||
while (k!=j)
|
||||
{
|
||||
int kk=ne[k];
|
||||
ne[k]=ne[j];
|
||||
k=kk;
|
||||
}
|
||||
}
|
||||
k=i=1;
|
||||
while (k<=n*m)
|
||||
{
|
||||
while (a[i]==0) i++;
|
||||
a[k++]=a[i++];
|
||||
}
|
||||
for (i=0;i<=n*m*2+10;i++)
|
||||
{
|
||||
ne[i]=i+1;
|
||||
b[i]=0;
|
||||
}
|
||||
for (i=0;i<n*m;i++)
|
||||
{
|
||||
scanf("%d%d",&col,&pos);
|
||||
k=pos;
|
||||
while (b[k]!=0) k=ne[k];
|
||||
b[k]=col;
|
||||
j=k;
|
||||
k=pos;
|
||||
while (k!=j)
|
||||
{
|
||||
int kk=ne[k];
|
||||
ne[k]=ne[j];
|
||||
k=kk;
|
||||
}
|
||||
}
|
||||
k=i=1;
|
||||
while (k<=n*m)
|
||||
{
|
||||
while (b[i]==0) i++;
|
||||
b[k++]=b[i++];
|
||||
}
|
||||
for (i=1;i<=n;i++) ff[i]=0;
|
||||
for (i=1;i<=n*m;i++)
|
||||
f[b[i]][ff[b[i]]++]=i;
|
||||
}
|
||||
void dp()
|
||||
{
|
||||
memset(tree,0,sizeof(tree));
|
||||
int i,j,k;
|
||||
int maxres=0;
|
||||
for (i=1;i<=n*m;i++)
|
||||
for (j=m-1;j>=0;j--)
|
||||
{
|
||||
k=f[a[i]][j];
|
||||
int t=ask(k-1)+1;
|
||||
maxres=Max(maxres,t);
|
||||
change(k,t,n*m);
|
||||
}
|
||||
printf("%d\n",maxres);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int cass,cas=0;
|
||||
for (scanf("%d\n",&cass);cass--;)
|
||||
{
|
||||
iin();
|
||||
cas++;
|
||||
printf("Case #%d: ",cas);
|
||||
dp();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,108 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
const int N=5005;
|
||||
const int M=1000001;
|
||||
const int inf=1<<30;
|
||||
int cnt,n,m,s,t;
|
||||
int head[N];
|
||||
int NN;
|
||||
struct Edge
|
||||
{
|
||||
int v,next,w;
|
||||
}edge[M];
|
||||
void addedge(int u,int v,int w)
|
||||
{
|
||||
edge[cnt].v=v;
|
||||
edge[cnt].w=w;
|
||||
edge[cnt].next=head[u];
|
||||
head[u]=cnt++;
|
||||
edge[cnt].v=u;
|
||||
edge[cnt].w=0;
|
||||
edge[cnt].next=head[v];
|
||||
head[v]=cnt++;
|
||||
}
|
||||
int sap()
|
||||
{
|
||||
int pre[N],cur[N],dis[N],gap[N];
|
||||
int flow=0,aug=inf,u;
|
||||
bool flag;
|
||||
for(int i=1;i<=NN;i++)
|
||||
{
|
||||
cur[i]=head[i];
|
||||
gap[i]=dis[i]=0;
|
||||
}
|
||||
gap[s]=NN;
|
||||
u=pre[s]=s;
|
||||
while(dis[s]<NN)
|
||||
{
|
||||
flag=0;
|
||||
for(int &j=cur[u];j!=-1;j=edge[j].next)
|
||||
{
|
||||
int v=edge[j].v;
|
||||
if(edge[j].w>0&&dis[u]==dis[v]+1)
|
||||
{
|
||||
flag=1;
|
||||
if(edge[j].w<aug) aug=edge[j].w;
|
||||
pre[v]=u;
|
||||
u=v;
|
||||
if(u==t)
|
||||
{
|
||||
flow+=aug;
|
||||
while(u!=s)
|
||||
{
|
||||
u=pre[u];
|
||||
edge[cur[u]].w-=aug;
|
||||
edge[cur[u]^1].w+=aug;
|
||||
}
|
||||
aug=inf;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(flag)
|
||||
continue;
|
||||
int mindis=NN;
|
||||
for(int j=head[u];j!=-1;j=edge[j].next)
|
||||
{
|
||||
int v=edge[j].v;
|
||||
if(edge[j].w>0&&dis[v]<mindis)
|
||||
{
|
||||
mindis=dis[v];
|
||||
cur[u]=j;
|
||||
}
|
||||
}
|
||||
if((--gap[dis[u]])==0)
|
||||
break;
|
||||
gap[dis[u]=mindis+1]++;
|
||||
u=pre[u];
|
||||
}
|
||||
return flow;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int A[501],B[501];
|
||||
while(scanf("%d%d",&n,&m)!=EOF)
|
||||
{
|
||||
memset(head,-1,sizeof(head));
|
||||
s=0;t=n+1; NN=n+2;
|
||||
for(int i=1;i<=n;i++)
|
||||
scanf("%d",&A[i]);
|
||||
for(int i=1;i<=n;i++)
|
||||
scanf("%d",&B[i]);
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
addedge(0,i,A[i]);
|
||||
addedge(i,t,B[i]);
|
||||
}
|
||||
for(int i=1;i<=m;i++)
|
||||
{
|
||||
int a,b,c;
|
||||
scanf("%d%d%d",&a,&b,&c);
|
||||
addedge(a,b,c);
|
||||
addedge(b,a,c);
|
||||
}
|
||||
printf("%d\n",sap());
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,66 @@
|
|||
#include<stdio.h>
|
||||
#include<set>
|
||||
#include<string>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
char strb[1010][100];
|
||||
struct In
|
||||
{
|
||||
char name[100];
|
||||
int flag;
|
||||
}stra[1010];
|
||||
char strc[1010][100];
|
||||
int main()
|
||||
{
|
||||
int a,b,c;
|
||||
int i,j,k;
|
||||
int mark;
|
||||
while(scanf("%d%d%d",&a,&b,&c)!=EOF)
|
||||
{
|
||||
mark=0;
|
||||
memset(stra,0,sizeof(stra));
|
||||
for(i=0;i<a;i++)
|
||||
{
|
||||
scanf("%s",stra[i].name);
|
||||
}
|
||||
for(i=0;i<b;i++)
|
||||
{
|
||||
scanf("%s",strb[i]);
|
||||
for(j=0;j<a;j++)
|
||||
{
|
||||
if(strcmp(stra[j].name,strb[i])==0)
|
||||
{
|
||||
stra[j].flag=1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
for(i=0;i<c;i++)
|
||||
{
|
||||
scanf("%s",strc[i]);
|
||||
for(j=0;j<a;j++)
|
||||
{
|
||||
if(strcmp(stra[j].name,strc[i])==0)
|
||||
{
|
||||
stra[j].flag=0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
int count=0;
|
||||
for(i=0;i<a;i++)
|
||||
{
|
||||
if(stra[i].flag==1)
|
||||
{
|
||||
if(count)
|
||||
printf(" ");
|
||||
count++;
|
||||
printf("%s",stra[i].name);
|
||||
}
|
||||
}
|
||||
if(count==0)
|
||||
printf("No enemy spy");
|
||||
printf("\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,55 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cctype>
|
||||
#define MAX_LEN 1000010
|
||||
char buf[MAX_LEN];
|
||||
char *ignore(char *p) {
|
||||
while (*p && isspace (*p)) ++p;
|
||||
return p;
|
||||
}
|
||||
int main() {
|
||||
while (gets(buf)) {
|
||||
char *p = buf + strlen(buf);
|
||||
while (gets(p) != NULL, *p) {
|
||||
p += strlen(p);
|
||||
}
|
||||
p = buf;
|
||||
while (*p) {
|
||||
p = ignore(p);
|
||||
if (*p == 'w') {
|
||||
p += 7;
|
||||
while (*p != '"') {
|
||||
putchar(*p);
|
||||
++p;
|
||||
}
|
||||
puts("");
|
||||
break;
|
||||
}
|
||||
p += 3;
|
||||
if (*p == '1') p += 2;
|
||||
else {
|
||||
p += 2;
|
||||
int cnt = 1;
|
||||
while (*p && cnt) {
|
||||
p = ignore(p);
|
||||
if (*p == 'w') {
|
||||
while (*p != ')') ++p;
|
||||
++p;
|
||||
continue;
|
||||
}
|
||||
if (*p == 'i') {
|
||||
++cnt;
|
||||
p += 5;
|
||||
continue;
|
||||
}
|
||||
if (*p == 'e') {
|
||||
--cnt;
|
||||
p += 4;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,123 @@
|
|||
# include<stdio.h>
|
||||
# include<string.h>
|
||||
# define N 200
|
||||
# define V 900
|
||||
int n,m,size,ak;
|
||||
int U[V],D[V];
|
||||
int L[V],R[V];
|
||||
int C[V];
|
||||
int H[N],S[N];
|
||||
int visit[17][17];
|
||||
int rr,cc;
|
||||
char map[17][17];
|
||||
void Link(int r,int c)
|
||||
{
|
||||
S[c]++;C[size]=c;
|
||||
U[size]=U[c];D[U[c]]=size;
|
||||
D[size]=c;U[c]=size;
|
||||
if(H[r]==-1) H[r]=L[size]=R[size]=size;
|
||||
else
|
||||
{
|
||||
L[size]=L[H[r]];R[L[H[r]]]=size;
|
||||
R[size]=H[r];L[H[r]]=size;
|
||||
}
|
||||
size++;
|
||||
}
|
||||
void remove(int c)
|
||||
{
|
||||
int i;
|
||||
for(i=D[c];i!=c;i=D[i])
|
||||
L[R[i]]=L[i],R[L[i]]=R[i];
|
||||
}
|
||||
void resume(int c)
|
||||
{
|
||||
int i;
|
||||
for(i=U[c];i!=c;i=U[i])
|
||||
L[R[i]]=R[L[i]]=i;
|
||||
}
|
||||
int h()
|
||||
{
|
||||
int i,j,k,count=0;
|
||||
bool hash[N];
|
||||
memset(hash,0,sizeof(hash));
|
||||
for(i=R[0];i;i=R[i])
|
||||
{
|
||||
if(hash[i]) continue;
|
||||
hash[i]=1;
|
||||
count++;
|
||||
for(j=D[i];j!=i;j=D[j])
|
||||
for(k=R[j];k!=j;k=R[k])
|
||||
hash[C[k]]=1;
|
||||
}
|
||||
return count;
|
||||
}
|
||||
void Dance(int k)
|
||||
{
|
||||
int i,j,Min,c;
|
||||
if(h()+k>=ak) return;
|
||||
if(!R[0])
|
||||
{
|
||||
if(k<ak) ak=k;
|
||||
return;
|
||||
}
|
||||
for(Min=N,i=R[0];i;i=R[i])
|
||||
if(Min>S[i]) Min=S[i],c=i;
|
||||
for(i=D[c];i!=c;i=D[i])
|
||||
{
|
||||
remove(i);
|
||||
for(j=R[i];j!=i;j=R[j])
|
||||
remove(j);
|
||||
Dance(k+1);
|
||||
for(j=L[i];j!=i;j=L[j])
|
||||
resume(j);
|
||||
resume(i);
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j,k1,k2;
|
||||
while(scanf("%d%d",&n,&m)!=EOF)
|
||||
{
|
||||
cc=0;
|
||||
memset(visit,0,sizeof(visit));
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
scanf("%s",map[i]);
|
||||
for(j=0;map[i][j];j++)
|
||||
if(map[i][j]=='#') visit[i][j]=++cc;
|
||||
}
|
||||
for(i=0;i<=cc;i++)
|
||||
{
|
||||
S[i]=0;
|
||||
D[i]=U[i]=i;
|
||||
L[i+1]=i;R[i]=i+1;
|
||||
}R[cc]=0;
|
||||
size=cc+1;
|
||||
memset(H,-1,sizeof(H));
|
||||
rr=0;
|
||||
for(i=1;i<n-1;i++)
|
||||
{
|
||||
for(j=1;j<m-1;j++)
|
||||
if(map[i][j]=='.')
|
||||
{
|
||||
rr++;
|
||||
k1=i-1;k2=j;
|
||||
while(map[k1][k2]=='.') k1--;
|
||||
if(map[k1][k2]=='#') Link(rr,visit[k1][k2]);
|
||||
k1=i+1;k2=j;
|
||||
while(map[k1][k2]=='.') k1++;
|
||||
if(map[k1][k2]=='#') Link(rr,visit[k1][k2]);
|
||||
k1=i;k2=j-1;
|
||||
while(map[k1][k2]=='.') k2--;
|
||||
if(map[k1][k2]=='#') Link(rr,visit[k1][k2]);
|
||||
k1=i;k2=j+1;
|
||||
while(map[k1][k2]=='.') k2++;
|
||||
if(map[k1][k2]=='#') Link(rr,visit[k1][k2]);
|
||||
}
|
||||
}
|
||||
ak=N;
|
||||
Dance(0);
|
||||
printf("%d\n",ak);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
#include<stdio.h>
|
||||
#include<iostream>
|
||||
#include<algorithm>
|
||||
#include<string.h>
|
||||
using namespace std;
|
||||
const int MAXN=100010;
|
||||
int q1[MAXN],q2[MAXN];
|
||||
int rear1,head1;
|
||||
int rear2,head2;
|
||||
int a[MAXN];
|
||||
int main()
|
||||
{
|
||||
int n,m,k;
|
||||
while(scanf("%d%d%d",&n,&m,&k)!=EOF)
|
||||
{
|
||||
rear1=head1=0;
|
||||
rear2=head2=0;
|
||||
int ans=0;
|
||||
int now=1;
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
scanf("%d",&a[i]);
|
||||
while(head1<rear1&&a[q1[rear1-1]]<a[i])rear1--;
|
||||
while(head2<rear2&&a[q2[rear2-1]]>a[i])rear2--;
|
||||
q1[rear1++]=i;
|
||||
q2[rear2++]=i;
|
||||
while(head1<rear1&&head2<rear2&&a[q1[head1]]-a[q2[head2]]>k)
|
||||
{
|
||||
if(q1[head1]<q2[head2])now=q1[head1++]+1;
|
||||
else now=q2[head2++]+1;
|
||||
}
|
||||
if(head1<rear1&&head2<rear2&&a[q1[head1]]-a[q2[head2]]>=m)
|
||||
{
|
||||
if(ans<i-now+1)ans=i-now+1;
|
||||
}
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,69 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#define MAXNUM 1005
|
||||
int num1[MAXNUM][MAXNUM];
|
||||
int num2[MAXNUM][MAXNUM];
|
||||
int sum1[MAXNUM][MAXNUM];
|
||||
int sum2[MAXNUM][MAXNUM];
|
||||
int main(void)
|
||||
{
|
||||
int n,m;
|
||||
memset(sum1,0,sizeof(sum1));
|
||||
memset(sum2,0,sizeof(sum2));
|
||||
while (~scanf("%d%d",&n,&m))
|
||||
{
|
||||
for(int i=1; i<=n; i++)
|
||||
for(int j=1; j<=n; j++)
|
||||
{
|
||||
scanf("%d",&num1[i][j]);
|
||||
sum1[i][j] = num1[i][j] + sum1[i][j-1] + sum1[i-1][j] - sum1[i-1][j-1];
|
||||
}
|
||||
for(int i=1; i<=m; i++)
|
||||
for(int j=1; j<=m; j++)
|
||||
{
|
||||
scanf("%d",&num2[i][j]);
|
||||
sum2[i][j] = num2[i][j] + sum2[i][j-1] + sum2[i-1][j] - sum2[i-1][j-1];
|
||||
}
|
||||
bool flag = false;
|
||||
for(int i=m; i<=n; i++)
|
||||
{
|
||||
for(int j=m; j<=n; j++)
|
||||
{
|
||||
if (sum2[m][m] == sum1[i][j] - sum1[i][j-m] - sum1[i-m][j] + sum1[i-m][j-m])
|
||||
{
|
||||
int k;
|
||||
for(k=1; k<=m; k++)
|
||||
if (sum2[k][k] != (sum1[i-m+k][j-m+k] - sum1[i-m][j-m+k] - sum1[i-m+k][j-m] + sum1[i-m][j-m]))
|
||||
{
|
||||
break;
|
||||
}
|
||||
if (k > m)
|
||||
{
|
||||
for(k=1; k<=m; k++)
|
||||
{
|
||||
int l;
|
||||
for(l=1; l<=m; l++)
|
||||
{
|
||||
if (num2[k][l] != num1[i-m+k][j-m+l])
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (l <= m)
|
||||
break;
|
||||
}
|
||||
if (k > m)
|
||||
flag = true;
|
||||
}
|
||||
}
|
||||
if (flag)
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (flag)
|
||||
printf("Yes\n");
|
||||
else
|
||||
printf("No\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,54 @@
|
|||
#include <stdio.h>
|
||||
#include <iostream>
|
||||
#include <math.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define FOR(i,s,e) for (int (i)=(s);(i)<(e);i++)
|
||||
const double INF = 1E20;
|
||||
const double eps = 1E-10;
|
||||
const int MAXV = 300;
|
||||
const double PI = 3.1415926535897932384626;
|
||||
struct POINT
|
||||
{
|
||||
double x;
|
||||
double y;
|
||||
POINT(double a=0, double b=0) { x=a; y=b;} //constructor
|
||||
};
|
||||
double myatan2(double y,double x)
|
||||
{
|
||||
double t = atan2(y,x);
|
||||
return t >= 0 ? t : t + 2*PI;
|
||||
}
|
||||
double angle[1010];
|
||||
POINT p[1011];
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
while (scanf("%d",&n),n>0)
|
||||
{
|
||||
FOR(i,0,n)
|
||||
{
|
||||
scanf("%lf%lf",&p[i].x,&p[i].y);
|
||||
}
|
||||
double max = -500;
|
||||
FOR(i,0,n)
|
||||
{
|
||||
int num = 0;
|
||||
FOR(j,0,n)
|
||||
if (i != j)
|
||||
angle[num++] = myatan2(p[i].y-p[j].y,p[i].x-p[j].x);
|
||||
sort(angle,angle+num);
|
||||
double min = INF;
|
||||
FOR(j,0,num-1)
|
||||
{
|
||||
double a = angle[j+1]-angle[j] < PI ? angle[j+1]-angle[j] : 2*PI-angle[j+1]-angle[j];
|
||||
if (min > a)
|
||||
min = a;
|
||||
}
|
||||
if (min > max)
|
||||
max = min ;
|
||||
}
|
||||
printf("%.4lf\n",fabs(max/PI*180));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,156 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <queue>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define ads(x) (x<0?-x:x)
|
||||
int n,m,k,life;
|
||||
int to[5][2] = {0,1,1,0,0,-1,-1,0,0,0};
|
||||
int map[105][105];
|
||||
bool vis[105][105][1005];
|
||||
struct period
|
||||
{
|
||||
char c;
|
||||
int t,v;
|
||||
} s[105][105];
|
||||
struct node
|
||||
{
|
||||
int x,y,step;
|
||||
};
|
||||
int check(int x,int y)
|
||||
{
|
||||
if(x<0 || x>n || y<0 || y>m)
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
void bfs()
|
||||
{
|
||||
node a,next;
|
||||
queue<node> Q;
|
||||
int i,j,flag,dis,tem;
|
||||
a.x = a.y = a.step = 0;
|
||||
Q.push(a);
|
||||
vis[0][0][0] = true;
|
||||
while(!Q.empty())
|
||||
{
|
||||
a = Q.front();
|
||||
Q.pop();
|
||||
if(a.step>life)
|
||||
break;
|
||||
if(a.x == n && a.y == m)
|
||||
{
|
||||
printf("%d\n",a.step);
|
||||
return ;
|
||||
}
|
||||
for(i = 0; i<5; i++)
|
||||
{
|
||||
next = a;
|
||||
next.x+=to[i][0];
|
||||
next.y+=to[i][1];
|
||||
next.step++;
|
||||
if(check(next.x,next.y)) continue;
|
||||
if(!s[next.x][next.y].t && !vis[next.x][next.y][next.step] && next.step<=life)
|
||||
{
|
||||
flag = 1;
|
||||
for(j = next.x-1; j>=0; j--)
|
||||
{
|
||||
if(s[j][next.y].t && s[j][next.y].c == 'S')
|
||||
{
|
||||
dis = next.x-j;
|
||||
if(dis%s[j][next.y].v) break;
|
||||
tem = next.step-dis/s[j][next.y].v;
|
||||
if(tem<0) break;
|
||||
if(tem%s[j][next.y].t==0)
|
||||
{
|
||||
flag = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(s[j][next.y].t)
|
||||
break;
|
||||
}
|
||||
if(!flag)
|
||||
continue;
|
||||
for(j = next.x+1; j<=n; j++)
|
||||
{
|
||||
if(s[j][next.y].t && s[j][next.y].c == 'N')
|
||||
{
|
||||
dis = j-next.x;
|
||||
if(dis%s[j][next.y].v) break;
|
||||
tem = next.step-dis/s[j][next.y].v;
|
||||
if(tem<0) break;
|
||||
if(tem%s[j][next.y].t==0)
|
||||
{
|
||||
flag = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(s[j][next.y].t)
|
||||
break;
|
||||
}
|
||||
if(!flag)
|
||||
continue;
|
||||
for(j = next.y-1; j>=0; j--)
|
||||
{
|
||||
if(s[next.x][j].t && s[next.x][j].c == 'E')
|
||||
{
|
||||
dis = next.y-j;
|
||||
if(dis%s[next.x][j].v) break;
|
||||
tem = next.step-dis/s[next.x][j].v;
|
||||
if(tem<0) break;
|
||||
if(tem%s[next.x][j].t==0)
|
||||
{
|
||||
flag = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(s[next.x][j].t)
|
||||
break;
|
||||
}
|
||||
if(!flag)
|
||||
continue;
|
||||
for(j = next.y+1; j<=m; j++)
|
||||
{
|
||||
if(s[next.x][j].t && s[next.x][j].c == 'W')
|
||||
{
|
||||
dis = j-next.y;
|
||||
if(dis%s[next.x][j].v) break;
|
||||
tem = next.step-dis/s[next.x][j].v;
|
||||
if(tem<0) break;
|
||||
if(tem%s[next.x][j].t==0)
|
||||
{
|
||||
flag = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(s[next.x][j].t)
|
||||
break;
|
||||
}
|
||||
if(!flag)
|
||||
continue;
|
||||
vis[next.x][next.y][next.step] = true;
|
||||
Q.push(next);
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("Bad luck!\n");
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j,x,y,t,v;
|
||||
char str[3];
|
||||
while(~scanf("%d%d%d%d",&n,&m,&k,&life))
|
||||
{
|
||||
memset(s,0,sizeof(s));
|
||||
memset(vis,false,sizeof(vis));
|
||||
for(i = 0; i<k; i++)
|
||||
{
|
||||
scanf("%s%d%d%d%d",str,&t,&v,&x,&y);
|
||||
s[x][y].v = v;
|
||||
s[x][y].t = t;
|
||||
s[x][y].c = str[0];
|
||||
}
|
||||
bfs();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,159 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <memory.h>
|
||||
using namespace std;
|
||||
const int inf = 1 << 29;
|
||||
const int maxn = 10002;
|
||||
struct node
|
||||
{
|
||||
int v,w;
|
||||
int next;
|
||||
}edge[maxn << 1];
|
||||
struct A
|
||||
{
|
||||
int path,num;
|
||||
int dep1,dep2;
|
||||
int num1,num2;
|
||||
}ans[maxn];
|
||||
int head[maxn];
|
||||
int n,idx;
|
||||
void init()
|
||||
{
|
||||
memset(head,-1,sizeof(head));
|
||||
idx = 0;
|
||||
return;
|
||||
}
|
||||
void addedge(int u,int v,int w)
|
||||
{
|
||||
edge[idx].v = v;
|
||||
edge[idx].w = w;
|
||||
edge[idx].next = head[u];
|
||||
head[u] = idx++;
|
||||
edge[idx].v = u;
|
||||
edge[idx].w = w;
|
||||
edge[idx].next = head[v];
|
||||
head[v] = idx++;
|
||||
return;
|
||||
}
|
||||
void read()
|
||||
{
|
||||
int u,v,w;
|
||||
for(int i=1;i<n;i++)
|
||||
{
|
||||
scanf("%d %d %d",&u,&v,&w);
|
||||
addedge(u,v,w);
|
||||
}
|
||||
return;
|
||||
}
|
||||
void dfs(int st,int pre)
|
||||
{
|
||||
ans[st].dep1 = ans[st].dep2 = -inf;
|
||||
ans[st].num1 = ans[st].num2 = ans[st].num = 0;
|
||||
bool leaf = true;
|
||||
for(int i=head[st];i != -1;i=edge[i].next)
|
||||
{
|
||||
if(edge[i].v == pre) continue;
|
||||
dfs(edge[i].v , st);
|
||||
leaf = false;
|
||||
int tmp = ans[edge[i].v].dep1 + edge[i].w;
|
||||
if(tmp > ans[st].dep1)
|
||||
{
|
||||
ans[st].dep2 = ans[st].dep1;
|
||||
ans[st].num2 = ans[st].num1;
|
||||
ans[st].dep1 = tmp;
|
||||
ans[st].num1 = ans[edge[i].v].num1;
|
||||
}
|
||||
else if(tmp == ans[st].dep1)
|
||||
{
|
||||
ans[st].num1 += ans[edge[i].v].num1;
|
||||
}
|
||||
else if(tmp > ans[st].dep2)
|
||||
{
|
||||
ans[st].dep2 = tmp;
|
||||
ans[st].num2 = ans[edge[i].v].num1;
|
||||
}
|
||||
else if(tmp == ans[st].dep2)
|
||||
{
|
||||
ans[st].num2 += ans[edge[i].v].num1;
|
||||
}
|
||||
}
|
||||
if(leaf)
|
||||
{
|
||||
ans[st].dep1 = ans[st].path = 0;
|
||||
ans[st].num1 = ans[st].num = 1;
|
||||
return;
|
||||
}
|
||||
int c1 = 0,c2 = 0;
|
||||
for(int i=head[st];i != -1;i=edge[i].next)
|
||||
{
|
||||
if(edge[i].v == pre) continue;
|
||||
int tmp = ans[edge[i].v].dep1 + edge[i].w;
|
||||
if(tmp == ans[st].dep1) c1++;
|
||||
else if(tmp == ans[st].dep2) c2++;
|
||||
}
|
||||
int type;
|
||||
if(c1 > 1) type = 1;
|
||||
else if(c2 > 0) type = 2;
|
||||
else type = 3;
|
||||
if(type == 1)
|
||||
{
|
||||
ans[st].path = ans[st].dep1 * 2;
|
||||
int sum = 0;
|
||||
for(int i=head[st];i != -1;i=edge[i].next)
|
||||
{
|
||||
if(edge[i].v == pre) continue;
|
||||
if(ans[edge[i].v].dep1 + edge[i].w == ans[st].dep1)
|
||||
{
|
||||
ans[st].num += sum * ans[edge[i].v].num1;
|
||||
sum += ans[edge[i].v].num1;
|
||||
}
|
||||
}
|
||||
}
|
||||
else if(type == 2)
|
||||
{
|
||||
ans[st].path = ans[st].dep1 + ans[st].dep2;
|
||||
for(int i=head[st];i != -1;i=edge[i].next)
|
||||
{
|
||||
if(edge[i].v == pre) continue;
|
||||
if(ans[edge[i].v].dep1 + edge[i].w == ans[st].dep2)
|
||||
{
|
||||
ans[st].num += ans[st].num1 * ans[edge[i].v].num1;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
ans[st].path = ans[st].dep1;
|
||||
ans[st].num = ans[st].num1;
|
||||
}
|
||||
return;
|
||||
}
|
||||
void solve()
|
||||
{
|
||||
dfs(1,0);
|
||||
int res = -inf,num = 0;
|
||||
for(int i=1;i<=n;i++)
|
||||
{
|
||||
if(ans[i].path > res)
|
||||
{
|
||||
res = ans[i].path;
|
||||
num = ans[i].num;
|
||||
}
|
||||
else if(ans[i].path == res)
|
||||
{
|
||||
num += ans[i].num;
|
||||
}
|
||||
}
|
||||
printf("%d %d\n",res,num);
|
||||
return;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(~scanf("%d",&n))
|
||||
{
|
||||
init();
|
||||
read();
|
||||
solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,74 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#define INF 1000000
|
||||
#define MAX_LIMT 110
|
||||
int get_max(int,int);
|
||||
int main()
|
||||
{
|
||||
int n,t;
|
||||
while(scanf("%d%d",&n,&t)!=EOF)
|
||||
{
|
||||
int i,j,k,dp[MAX_LIMT][MAX_LIMT];
|
||||
memset(dp,0,sizeof(dp));
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
int m,s,cost[MAX_LIMT],val[MAX_LIMT];
|
||||
scanf("%d%d",&m,&s);
|
||||
for(j=1;j<=m;j++)
|
||||
{
|
||||
scanf("%d%d",&cost[j],&val[j]);
|
||||
}
|
||||
if(s==0)
|
||||
{
|
||||
for(j=0;j<=t;j++)
|
||||
{
|
||||
dp[i][j]=-INF;
|
||||
}
|
||||
for(j=1;j<=m;j++)
|
||||
{
|
||||
for(k=t;k>=cost[j];k--)
|
||||
{
|
||||
dp[i][k]=get_max( dp[i][k],dp[i][k-cost[j]]+val[j]);
|
||||
dp[i][k]=get_max( dp[i][k],dp[i-1][k-cost[j]]+val[j]);
|
||||
}
|
||||
}
|
||||
}
|
||||
else if(s==1)
|
||||
{
|
||||
for(j=0;j<=t;j++)
|
||||
{
|
||||
dp[i][j]=dp[i-1][j];
|
||||
}
|
||||
for(j=1;j<=m;j++)
|
||||
{
|
||||
for(k=t;k>=cost[j];k--)
|
||||
{
|
||||
dp[i][k]=get_max(dp[i][k],dp[i-1][k-cost[j]]+val[j]);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for(j=0;j<=t;j++)
|
||||
{
|
||||
dp[i][j]=dp[i-1][j];
|
||||
}
|
||||
for(j=1;j<=m;j++)
|
||||
{
|
||||
for(k=t;k>=cost[j];k--)
|
||||
{
|
||||
dp[i][k]=get_max( dp[i][k],dp[i][k-cost[j]]+val[j]);
|
||||
dp[i][k]=get_max( dp[i][k],dp[i-1][k-cost[j]]+val[j]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
dp[n][t]=get_max(dp[n][t],-1);
|
||||
printf("%d\n",dp[n][t]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
int get_max(int x,int y)
|
||||
{
|
||||
return x>y?x:y;
|
||||
}
|
||||
|
|
@ -0,0 +1,73 @@
|
|||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <ctype.h>
|
||||
#include <math.h>
|
||||
#include <time.h>
|
||||
#include <stack>
|
||||
#include <queue>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define ull unsigned __int64
|
||||
#define ll __int64
|
||||
#define lson l,mid,rt<<1
|
||||
#define rson mid+1,r,rt<<1|1
|
||||
#define middle (l+r)>>1
|
||||
#define MOD 1000000007
|
||||
#define esp (1e-4)
|
||||
const int INF=0x3F3F3F3F;
|
||||
const double DINF=10001.00;
|
||||
const int N=1010;
|
||||
int n,m;
|
||||
int mtx[N<<1][N<<1],X[N<<1],Y[N<<1],xc,yc,cnt,vis[N];
|
||||
struct node{
|
||||
int x1,y1,x2,y2;
|
||||
void write(){
|
||||
scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
|
||||
if(x1>x2) swap(x1,x2);
|
||||
if(y1>y2) swap(y1,y2);
|
||||
}
|
||||
}a[N];
|
||||
int bs(int key,int size,int A[]){
|
||||
int l=0,r=size-1,mid;
|
||||
while(l<=r){
|
||||
mid=middle;
|
||||
if(key>A[mid]) l=mid+1;
|
||||
else if(key<A[mid]) r=mid-1;
|
||||
else return mid;
|
||||
}return -1;
|
||||
}
|
||||
int main(){
|
||||
int i,j,k,r,c,x1,y1,x2,y2;
|
||||
while(~scanf("%d%d%d",&r,&c,&n)){
|
||||
for(i=m=0;i<n;i++){
|
||||
a[i].write();
|
||||
X[m]=a[i].x1,Y[m]=a[i].y1,m++;
|
||||
X[m]=a[i].x2,Y[m]=a[i].y2,m++;
|
||||
}
|
||||
sort(X,X+m);sort(Y,Y+m);
|
||||
for(i=xc=1;i<m;i++) if(X[i]!=X[i-1]) X[xc++]=X[i];
|
||||
for(i=yc=1;i<m;i++) if(Y[i]!=Y[i-1]) Y[yc++]=Y[i];
|
||||
memset(mtx,0,sizeof(mtx));
|
||||
for(i=0;i<n;i++){
|
||||
x1=bs(a[i].x1,xc,X),x2=bs(a[i].x2,xc,X);
|
||||
y1=bs(a[i].y1,yc,Y),y2=bs(a[i].y2,yc,Y);
|
||||
for(j=x1;j<=x2;j++)
|
||||
for(k=y1;k<=y2;k++)
|
||||
mtx[j][k]=i;
|
||||
}
|
||||
memset(vis,0,sizeof(vis));
|
||||
for(i=cnt=0;i<xc;i++){
|
||||
for(j=0;j<yc;j++) if(mtx[i][j]){
|
||||
if(!vis[mtx[i][j]]) cnt++,vis[mtx[i][j]]=1;
|
||||
}
|
||||
}
|
||||
printf("%d\n",n-cnt);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
#include <stdio.h>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <string.h>
|
||||
using namespace std;
|
||||
int SG(int x)
|
||||
{
|
||||
int tmp = x;
|
||||
int cnt = 0;
|
||||
while(tmp)
|
||||
{
|
||||
if(tmp&1)cnt++;
|
||||
tmp>>=1;
|
||||
}
|
||||
if(cnt&1)return 2*x;
|
||||
else return 2*x + 1;
|
||||
}
|
||||
int a[110];
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
while(scanf("%d",&n)==1)
|
||||
{
|
||||
for(int i = 0;i < n;i++)
|
||||
scanf("%d",&a[i]);
|
||||
sort(a,a+n);
|
||||
n = unique(a,a+n)-a;
|
||||
int sum = 0;
|
||||
for(int i = 0;i < n;i++)
|
||||
sum ^= SG(a[i]);
|
||||
if(sum)printf("No\n");
|
||||
else printf("Yes\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
#include<algorithm>
|
||||
#include <cstring>
|
||||
#include<cstdio>
|
||||
#include<stdlib.h>
|
||||
#define L(i) (1 << (i))
|
||||
#define MAXM 3000000
|
||||
using namespace std;
|
||||
int dp[3000000][22];
|
||||
int dis[22][22];
|
||||
int f[22];
|
||||
int main()
|
||||
{
|
||||
int n, m;
|
||||
while(~scanf("%d%d",&n, &m))
|
||||
{
|
||||
memset(f,0,sizeof(f));
|
||||
for(int i = 0;i < L(n);i ++)
|
||||
for(int j = 0;j < n;j ++)
|
||||
dp[i][j] = MAXM;
|
||||
for(int i = 0;i < n;i ++)
|
||||
for(int j = 0;j < n;j ++)
|
||||
scanf("%d",dis[i] + j);
|
||||
for(int i = 0;i < m;i ++)
|
||||
{
|
||||
int u, v;
|
||||
scanf("%d%d", &u,&v);
|
||||
f[v] |= L(u);
|
||||
}
|
||||
dp[1][0] = 0;
|
||||
int S = L(n);
|
||||
for(int s = 0;s < S;s ++)
|
||||
for(int i = 0;i < n;i ++)
|
||||
if(dp[s][i] == MAXM)continue;
|
||||
else
|
||||
for(int j = 1;j < n;j ++)
|
||||
{
|
||||
if(dis[i][j] == -1)continue;
|
||||
if(!(s & L(i)))continue;
|
||||
if(s & L(j))continue;
|
||||
if(f[j] != (s & f[j]))continue;
|
||||
dp[s|L(j)][j] = min(dp[s][i] + dis[i][j],dp[s|L(j)][j]);
|
||||
}
|
||||
int ans = MAXM;
|
||||
S = L(n) - 1;
|
||||
for(int i = 0;i < n;i ++)
|
||||
ans = min(ans, dp[S][i]);
|
||||
if(ans >= MAXM)printf("-1\n");
|
||||
else printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,156 @@
|
|||
#include <map>
|
||||
#include <set>
|
||||
#include <list>
|
||||
#include <queue>
|
||||
#include <cmath>
|
||||
#include <stack>
|
||||
#include <bitset>
|
||||
#include <cstdio>
|
||||
#include <cctype>
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#include <sstream>
|
||||
#include <cstring>
|
||||
#include <cstdlib>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define lowbit(x) (x&(-x))
|
||||
#define ff first
|
||||
#define ss second
|
||||
#define all(c) c.begin(),c.end()
|
||||
#define PB push_back
|
||||
#define MP make_pair
|
||||
#define SZ(a) ((int)a.size())
|
||||
#define CC(a,b) memset(a,b,sizeof(a))
|
||||
#define rep(i,a,b) for(int i=(a);i<(b);i++)
|
||||
#define repe(i,a,b) for(int i=(a);i<=(b);i++)
|
||||
#define reps(i,s) for(int i=0;s[i];i++)
|
||||
#define repi(it,c) for(typeof(c.begin()) it=c.begin();it!=c.end();it++)
|
||||
#define inf 0x7f7f7f7f
|
||||
#define lson l,m,rt<<1
|
||||
#define rson m+1,r,rt<<1|1
|
||||
#define LL long long
|
||||
#define ULL unsigned long long
|
||||
#define L(x) (x<<1)
|
||||
#define R(x) (x<<1|1)
|
||||
#define maxn 15
|
||||
#define maxm 505
|
||||
#define mod 1000000007
|
||||
#define SQ(x) ((x)*(x))
|
||||
const double eps=1e-6;
|
||||
const double pi=acos(-1.0);
|
||||
template<class Z>inline bool checkmax(Z &a,Z b){if(a==-1||a<b){a=b;return true;}return false;}
|
||||
template<class Z>inline bool checkmin(Z &a,Z b){if(a==-1||a>b){a=b;return true;}return false;}
|
||||
template<class Z>inline bool mymax(Z &a,Z b){if(a<b){a=b;return true;}return false;}
|
||||
template<class Z>inline bool mymin(Z &a,Z b){if(a>b){a=b;return true;}return false;}
|
||||
int cas=1; void printcase(){printf("Case #%d: ",cas++);}
|
||||
int pre[maxn][maxn];
|
||||
int dp[1<<maxn][maxn];
|
||||
string str[maxn],a[maxn];
|
||||
int n;
|
||||
map<string,bool>has;
|
||||
void init() {
|
||||
CC(pre,0);
|
||||
CC(dp,-1);
|
||||
has.clear();
|
||||
}
|
||||
void input() {
|
||||
int idx=0,m=0;
|
||||
rep(i,0,n) {
|
||||
string b;
|
||||
cin>>b;
|
||||
if(!has[b]) {
|
||||
has[b]=true;
|
||||
a[idx++]=b;
|
||||
}
|
||||
}
|
||||
n=idx;
|
||||
rep(i,0,n) {
|
||||
int flag=0;
|
||||
rep(j,0,n) {
|
||||
if(i==j) continue;
|
||||
if(a[j].find(a[i])!=a[j].npos) {
|
||||
flag=1; break;
|
||||
}
|
||||
}
|
||||
if(!flag) str[m++]=a[i];
|
||||
}
|
||||
n=m;
|
||||
sort(str,str+n);
|
||||
}
|
||||
void initpre() {
|
||||
rep(i,0,n) {
|
||||
rep(j,0,n) {
|
||||
if(i==j) continue;
|
||||
rep(k,0,SZ(str[i])) {
|
||||
int ii,jj;
|
||||
for(ii=k,jj=0;ii<SZ(str[i]);ii++,jj++) {
|
||||
if(str[i][ii]!=str[j][jj]) break;
|
||||
}
|
||||
if(ii==SZ(str[i])) {
|
||||
pre[i][j]=SZ(str[i])-k;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
void solve() {
|
||||
int tol=(1<<n);
|
||||
rep(i,0,n) {
|
||||
dp[1<<i][i]=str[i].size();
|
||||
}
|
||||
rep(sta,0,tol) {
|
||||
rep(i,0,n) {
|
||||
if(dp[sta][i]==-1) continue;
|
||||
rep(j,0,n) {
|
||||
if(sta&(1<<j)) continue;
|
||||
checkmin(dp[sta|(1<<j)][j],dp[sta][i]+SZ(str[j])-pre[j][i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
int mini=-1;
|
||||
rep(i,0,n) {
|
||||
if(dp[tol-1][i]==-1) continue;
|
||||
checkmin(mini,dp[tol-1][i]);
|
||||
}
|
||||
string ans="";
|
||||
string temp="";
|
||||
int sta=tol-1;
|
||||
int p=13;
|
||||
while(sta) {
|
||||
string a=temp;
|
||||
int idx=-1;
|
||||
rep(i,0,n) {
|
||||
if(dp[sta][i]+temp.size()-pre[p][i]==mini) {
|
||||
if(idx==-1) {
|
||||
idx=i;
|
||||
a=a.substr(0,a.size()-pre[p][i])+str[i];
|
||||
}
|
||||
else {
|
||||
string b=temp;
|
||||
b=b.substr(0,b.size()-pre[p][i])+str[i];
|
||||
if(a>b) {
|
||||
a=b;
|
||||
idx=i;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
temp=a;
|
||||
ans+=str[idx];
|
||||
p=idx;
|
||||
sta^=(1<<idx);
|
||||
}
|
||||
printcase();
|
||||
cout<<temp<<endl;
|
||||
}
|
||||
int main() {
|
||||
while(~scanf("%d",&n)) {
|
||||
init();
|
||||
input();
|
||||
initpre();
|
||||
solve();
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
#include<iostream>
|
||||
using namespace std;
|
||||
bool ch[40000002] = {0};
|
||||
int a=30000000, b=40000000;
|
||||
void init()
|
||||
{
|
||||
int i, j;
|
||||
for( i=2; i <= 6325; i++ )
|
||||
{
|
||||
if(!ch[i])
|
||||
{
|
||||
for( j=i+i; j <= 6325; j += i)
|
||||
ch[j] = true;
|
||||
for( j=a/i*i; j <= b; j+=i)
|
||||
ch[j] = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
init();
|
||||
int i;
|
||||
for( i=a; i < b; i++ )
|
||||
{
|
||||
if(ch[i] == false)
|
||||
printf("%d\n", i);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
#include<stdio.h>
|
||||
int main()
|
||||
{
|
||||
int T,c=0,n,i;
|
||||
__int64 a,b,x,y;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
a=b=0;
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
scanf("%I64d%I64d",&x,&y);
|
||||
while(x>1&&y>1)
|
||||
{
|
||||
x=x>>1;
|
||||
y=y>>1;
|
||||
}
|
||||
if(x==1) b+=y-1;
|
||||
if(y==1) a+=x-1;
|
||||
}
|
||||
printf("Case %d: ",++c);
|
||||
printf(a>b?"Alice\n":"Bob\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,84 @@
|
|||
#include "iostream"
|
||||
#include "algorithm"
|
||||
#include "cstdio"
|
||||
#include "cstdlib"
|
||||
#include "cstring"
|
||||
using namespace std;
|
||||
#define _ASSERT(a) ({fprintf(stderr,"%s:%d: %s\n", __FILE__, __LINE__, #a); exit(-1);})
|
||||
#define _FOREACH(a, b) for(__typeof(b.begin())a=b.begin(), a##ed__=b.end(); a!=a##ed__; a++)
|
||||
#define _FOREACHC(a, b, cond) for (__typeof(b) a=b;(cond); b++, a=b)
|
||||
#define _QUEUEPROC(cond, U, V) \
|
||||
for(int u=(U);cond;u=(U))\
|
||||
_FOREACH(v, V)
|
||||
#define _STACKPROC(cond, U, V) \
|
||||
for (int u=(U); cond; u=(U))\
|
||||
for (bool child=false; !child; child=true)\
|
||||
_FOREACHC(v, (V), !child)
|
||||
#define _INCREMENT(over, ...)\
|
||||
do\
|
||||
{\
|
||||
static int over = 0;\
|
||||
(over)++;\
|
||||
__VA_ARGS__;\
|
||||
}while(0)
|
||||
#define rangedo(i, s, t)\
|
||||
i=s; i!=t; i++
|
||||
#define each(a, b)\
|
||||
__typeof(b.begin())a=b.begin(), a##ed__=b.end(); a!=a##ed__; a++
|
||||
int T;
|
||||
int N, M;
|
||||
int f[16][16][16][16];
|
||||
int vst[16][16][16][16];
|
||||
struct Save{
|
||||
int x1, y1, x2, y2;
|
||||
}sav[1001];
|
||||
const int modulo = 100000;
|
||||
int iter[4];
|
||||
int main()
|
||||
{
|
||||
scanf("%d", &T);
|
||||
while (T--)
|
||||
{
|
||||
scanf("%d%d", &N, &M);
|
||||
memset(vst, 0, sizeof(vst));
|
||||
for (int i=0; i<M; i++)
|
||||
scanf("%d%d%d%d", &sav[i].x1, &sav[i].y1, &sav[i].x2, &sav[i].y2);
|
||||
for (rangedo(iter[0], 0, N+1))
|
||||
for (rangedo(iter[1], 0, N+1))
|
||||
for (rangedo(iter[2], 0, N+1))
|
||||
for (rangedo(iter[3], 0, N+1))
|
||||
for (int rangedo(i, 0, M))
|
||||
if ( (iter[sav[i].x1-1] < sav[i].y1)!=
|
||||
(iter[sav[i].x2-1] < sav[i].y2) )
|
||||
{
|
||||
vst[iter[0]][iter[1]][iter[2]][iter[3]]=true;
|
||||
break;
|
||||
}
|
||||
memset(f , 0, sizeof( f));
|
||||
f[0][0][0][0]=1;
|
||||
for (int rangedo(color, 1, 257))
|
||||
{
|
||||
for (int rangedo(colum, 0, 4))
|
||||
for (rangedo(iter[0], 0, N+1))
|
||||
for (rangedo(iter[1], 0, N+1))
|
||||
for (rangedo(iter[2], 0, N+1))
|
||||
for (rangedo(iter[3], 0, N+1))
|
||||
if (iter[colum])
|
||||
{
|
||||
int &dp = f[iter[0]][iter[1]][iter[2]][iter[3]];
|
||||
iter[colum]--;
|
||||
dp += f[iter[0]][iter[1]][iter[2]][iter[3]];
|
||||
iter[colum]++;
|
||||
if (dp>=modulo) dp-=modulo;
|
||||
}
|
||||
for (rangedo(iter[0], 0, N+1))
|
||||
for (rangedo(iter[1], 0, N+1))
|
||||
for (rangedo(iter[2], 0, N+1))
|
||||
for (rangedo(iter[3], 0, N+1))
|
||||
if (vst[iter[0]][iter[1]][iter[2]][iter[3]])
|
||||
f[iter[0]][iter[1]][iter[2]][iter[3]]=0;
|
||||
}
|
||||
_INCREMENT(ncase,
|
||||
printf("Case %d: %05d\n", ncase, f[N][N][N][N]));
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,108 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<string.h>
|
||||
using namespace std;
|
||||
const int base=10000;
|
||||
const int width=4;
|
||||
const int N=1300;
|
||||
struct bint
|
||||
{
|
||||
int ln,v[N];
|
||||
bint(int r=0)
|
||||
{
|
||||
for(ln=0;r>0;r/=base)
|
||||
v[ln++]=r%base;
|
||||
}
|
||||
bint operator = (const bint& r)
|
||||
{
|
||||
memcpy(this,&r,(r.ln+1)*sizeof(int));
|
||||
}
|
||||
};
|
||||
bool operator < (const bint& a,const bint& b)
|
||||
{
|
||||
int i;
|
||||
if(a.ln!=b.ln) return a.ln<b.ln;
|
||||
for(i=a.ln-1;i>=0&&a.v[i]==b.v[i];i--);
|
||||
return i<0?0:a.v[i]<b.v[i];
|
||||
}
|
||||
bool operator <= (const bint& a,const bint& b)
|
||||
{
|
||||
return !(b<a);
|
||||
}
|
||||
bint operator + (const bint& a,const bint& b)
|
||||
{
|
||||
bint res;
|
||||
int i,cy=0;
|
||||
for(i=0;i<a.ln||i<b.ln||cy>0;i++)
|
||||
{
|
||||
if(i<a.ln) cy+=a.v[i];
|
||||
if(i<b.ln) cy+=b.v[i];
|
||||
res.v[i]=cy%base;cy/=base;
|
||||
}
|
||||
res.ln=i;
|
||||
return res;
|
||||
}
|
||||
bint operator * (const bint& a,const bint& b)
|
||||
{
|
||||
bint res;res.ln=0;
|
||||
if(0==b.ln){
|
||||
res.v[0]=0;return res;
|
||||
}
|
||||
int i,j,cy;
|
||||
for(i=0;i<a.ln;i++)
|
||||
for(j=cy=0;j<b.ln||cy>0;j++,cy/=base)
|
||||
{
|
||||
if(j<b.ln) cy+=a.v[i]*b.v[j];
|
||||
if(i+j<res.ln) cy+=res.v[i+j];
|
||||
if(i+j>=res.ln) res.v[res.ln++]=cy%base;
|
||||
else res.v[i+j]=cy%base;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
void write(const bint& v)
|
||||
{
|
||||
int i;
|
||||
printf("%d",v.ln==0?0:v.v[v.ln-1]);
|
||||
for(i=v.ln-2;i>=0;i--)
|
||||
printf("%04d",v.v[i]);
|
||||
printf("\n");
|
||||
}
|
||||
char buf[10];
|
||||
bint b[10];
|
||||
struct o
|
||||
{
|
||||
int a,b,o;
|
||||
}o[400000];
|
||||
bool flag[10],cal[400000];
|
||||
int main()
|
||||
{
|
||||
for(int i=0;i<10;i++) b[i]=1;
|
||||
int i=0;
|
||||
while(scanf("%s",buf)!=EOF&&buf[0]!='#')
|
||||
{
|
||||
o[i].a=buf[0]-'A';
|
||||
if(buf[1]=='+') o[i].o=0,o[i].b=buf[3]-'A';
|
||||
else if(buf[1]=='*') o[i].o=1,o[i].b=buf[3]-'A';
|
||||
else o[i].o=2,o[i].b=buf[2]-'A';
|
||||
i++;
|
||||
}
|
||||
for(int j=0;j<10;j++) flag[j]=true;
|
||||
for(int j=i-1;j>=0;j--)
|
||||
{
|
||||
cal[j]=flag[o[j].a];
|
||||
if(o[j].o==2)
|
||||
flag[o[j].a]=false,flag[o[j].b]=true;
|
||||
}
|
||||
for(int j=0;j<i;j++)
|
||||
{
|
||||
if(cal[j])
|
||||
{
|
||||
if(o[j].o==0) b[o[j].a]=b[o[j].a]+b[o[j].b];
|
||||
else if(o[j].o==1) b[o[j].a]=b[o[j].a]*b[o[j].b];
|
||||
else b[o[j].a]=b[o[j].b];
|
||||
}
|
||||
}
|
||||
for(int i=0;i<10;i++)
|
||||
write(b[i]);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,127 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<string.h>
|
||||
using namespace std;
|
||||
const int base=10000;
|
||||
const int width=4;
|
||||
const int N=1300;
|
||||
char s[1000];
|
||||
struct bint
|
||||
{
|
||||
int ln,v[N];
|
||||
bint(int r=0)
|
||||
{
|
||||
for(ln=0;r>0;r/=base)
|
||||
v[ln++]=r%base;
|
||||
}
|
||||
bint operator = (const bint& r)
|
||||
{
|
||||
memcpy(this,&r,(r.ln+1)*sizeof(int));
|
||||
}
|
||||
};
|
||||
bool operator < (const bint& a,const bint& b)
|
||||
{
|
||||
int i;
|
||||
if(a.ln!=b.ln) return a.ln<b.ln;
|
||||
for(i=a.ln-1;i>=0&&a.v[i]==b.v[i];i--);
|
||||
return i<0?0:a.v[i]<b.v[i];
|
||||
}
|
||||
bool operator <= (const bint& a,const bint& b)
|
||||
{
|
||||
return !(b<a);
|
||||
}
|
||||
bint operator + (const bint& a,const bint& b)
|
||||
{
|
||||
bint res;
|
||||
int i,cy=0;
|
||||
for(i=0;i<a.ln||i<b.ln||cy>0;i++)
|
||||
{
|
||||
if(i<a.ln) cy+=a.v[i];
|
||||
if(i<b.ln) cy+=b.v[i];
|
||||
res.v[i]=cy%base;cy/=base;
|
||||
}
|
||||
res.ln=i;
|
||||
return res;
|
||||
}
|
||||
bint operator - (const bint &a,const bint &b)
|
||||
{
|
||||
bint res;int i,cy=0;
|
||||
for(res.ln=a.ln,i=0;i<res.ln;i++)
|
||||
{
|
||||
res.v[i]=a.v[i]-cy;
|
||||
if(i<b.ln) res.v[i]-=b.v[i];
|
||||
if(res.v[i]<0) cy=1,res.v[i]+=base;
|
||||
else cy=0;
|
||||
}
|
||||
while(res.ln>0&&res.v[res.ln-1]==0) res.ln--;
|
||||
return res;
|
||||
}
|
||||
bint operator * (const bint& a,const bint& b)
|
||||
{
|
||||
bint res;res.ln=0;
|
||||
if(0==b.ln){
|
||||
res.v[0]=0;return res;
|
||||
}
|
||||
int i,j,cy;
|
||||
for(i=0;i<a.ln;i++)
|
||||
for(j=cy=0;j<b.ln||cy>0;j++,cy/=base)
|
||||
{
|
||||
if(j<b.ln) cy+=a.v[i]*b.v[j];
|
||||
if(i+j<res.ln) cy+=res.v[i+j];
|
||||
if(i+j>=res.ln) res.v[res.ln++]=cy%base;
|
||||
else res.v[i+j]=cy%base;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
bint operator / (const bint& a,const bint& b)
|
||||
{
|
||||
bint tmp,mod,res;
|
||||
int i,lf,rg,mid;
|
||||
mod.v[0]=mod.ln=0;
|
||||
for(i=a.ln-1;i>=0;i--)
|
||||
{
|
||||
mod=mod*base+a.v[i];
|
||||
for(lf=0,rg=base-1;lf<rg;)
|
||||
{
|
||||
mid=(lf+rg+1)/2;
|
||||
if(b*mid<=mod) lf=mid;
|
||||
else rg=mid-1;
|
||||
}
|
||||
res.v[i]=lf;
|
||||
mod=mod-b*lf;
|
||||
}
|
||||
res.ln=a.ln;
|
||||
while(res.ln>0&&res.v[res.ln-1]==0) res.ln--;
|
||||
return res;
|
||||
}
|
||||
void write(const bint& v)
|
||||
{
|
||||
int i,len;
|
||||
sprintf(s,"%d",v.ln==0?0:v.v[v.ln-1]);
|
||||
len=strlen(s);
|
||||
for(i=v.ln-2;i>=0;i--)
|
||||
{
|
||||
sprintf(s+len,"%04d",v.v[i]);
|
||||
len=strlen(s);
|
||||
}
|
||||
sprintf(s+len,"\0");
|
||||
}
|
||||
int main()
|
||||
{
|
||||
bint ans,a=24,b=17,c=6;
|
||||
int t,cas=1;
|
||||
cin>>t;
|
||||
while(t--)
|
||||
{
|
||||
int m;
|
||||
cin>>m;
|
||||
bint n=m;
|
||||
ans=(b*n*n*n*n+c*n*n+n*n*n*n*n*n*n*n)/a;
|
||||
write(ans);
|
||||
cout<<"Case "<<cas++<<": ";
|
||||
if(strlen(s)>15)
|
||||
cout<<s+strlen(s)-15<<endl;
|
||||
else
|
||||
cout<<s<<endl;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,61 @@
|
|||
#include <math.h>
|
||||
#include <stdio.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define min(a,b) a < b ? a : b
|
||||
struct TT
|
||||
{
|
||||
int x,y;
|
||||
bool operator <(const TT& s)const
|
||||
{
|
||||
return x < s.x;
|
||||
}
|
||||
}A[1002];
|
||||
bool One_Line(const TT& s1,const TT& s2,const TT& s3)
|
||||
{
|
||||
return (s2.y-s1.y)*(s3.x-s2.x) == (s3.y-s2.y)*(s2.x-s1.x);
|
||||
}
|
||||
double dis(const TT& s1,const TT& s2)
|
||||
{
|
||||
return sqrt( (double)(s1.x-s2.x)*(s1.x-s2.x) + (s1.y-s2.y)*(s1.y-s2.y) );
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int z,n,ncase=0;
|
||||
scanf("%d",&z);
|
||||
while(z--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
for(int i=0;i<n;i++)
|
||||
scanf("%d%d",&A[i].x,&A[i].y);
|
||||
sort(A,A+n);
|
||||
double ans = 1e7;
|
||||
for(int i=0;i<n-2;i++)
|
||||
{
|
||||
for(int j=i+1;j<n-1;j++)
|
||||
{
|
||||
if(ans <= 2*(A[j].x-A[i].x))
|
||||
break;
|
||||
double a = dis(A[i],A[j]);
|
||||
if(ans <= 2*a)
|
||||
continue;
|
||||
for(int k=j+1;k<n;k++)
|
||||
{
|
||||
if(ans <= 2*(A[k].x-A[i].x))
|
||||
break;
|
||||
if(One_Line(A[i],A[j],A[k]))
|
||||
continue;
|
||||
double b = dis(A[j],A[k]);
|
||||
double c = dis(A[k],A[i]);
|
||||
ans = min(ans,a+b+c);
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("Case %d: ",++ncase);
|
||||
if(ans == 1e7)
|
||||
puts("No Solution");
|
||||
else
|
||||
printf("%.3f\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,68 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
#define MAXN 22
|
||||
#define inf 1<<28
|
||||
int map[MAXN][MAXN];
|
||||
int pre[MAXN];
|
||||
int level[MAXN];
|
||||
int gap[MAXN];
|
||||
int SAP(int vs,int vt){
|
||||
memset(pre,-1,sizeof(pre));
|
||||
memset(level,0,sizeof(level));
|
||||
memset(gap,0,sizeof(gap));
|
||||
int v,u=pre[vs]=vs,maxflow=0,aug=inf;
|
||||
gap[0]=vt;
|
||||
while(level[vs]<vt){
|
||||
for(v=1;v<=vt;v++){
|
||||
if(map[u][v]>0&&level[u]==level[v]+1){
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(v<=vt){
|
||||
pre[v]=u;
|
||||
u=v;
|
||||
if(v==vt){
|
||||
aug=inf;
|
||||
for(int i=v;i!=vs;i=pre[i]){
|
||||
if(aug>map[pre[i]][i])aug=map[pre[i]][i];
|
||||
}
|
||||
maxflow+=aug;
|
||||
for(int i=v;i!=vs;i=pre[i]){
|
||||
map[pre[i]][i]-=aug;
|
||||
map[i][pre[i]]+=aug;
|
||||
}
|
||||
u=vs;
|
||||
}
|
||||
}else {
|
||||
int minlevel=vt;
|
||||
for(v=1;v<=vt;v++){
|
||||
if(map[u][v]>0&&minlevel>level[v]){
|
||||
minlevel=level[v];
|
||||
}
|
||||
}
|
||||
gap[level[u]]--;
|
||||
if(gap[level[u]]==0)break;
|
||||
level[u]=minlevel+1;
|
||||
gap[level[u]]++;
|
||||
u=pre[u];
|
||||
}
|
||||
}
|
||||
return maxflow;
|
||||
}
|
||||
int main(){
|
||||
int _case,t=1,n,m,u,v,cap;
|
||||
scanf("%d",&_case);
|
||||
while(_case--){
|
||||
memset(map,0,sizeof(map));
|
||||
scanf("%d%d",&n,&m);
|
||||
while(m--){
|
||||
scanf("%d%d%d",&u,&v,&cap);
|
||||
map[u][v]+=cap;
|
||||
}
|
||||
printf("Case %d: ",t++);
|
||||
printf("%d\n",SAP(1,n));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,159 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int MAXN = 800;
|
||||
int n,head,tail,start,finish,match[MAXN],fa[MAXN],base[MAXN],Q[MAXN];
|
||||
int adj[MAXN][MAXN];
|
||||
bool mark[MAXN],in_blossom[MAXN],in_queue[MAXN];
|
||||
inline void Contract (int x,int y){
|
||||
memset(mark,0,sizeof(mark));
|
||||
memset(in_blossom,0,sizeof(in_blossom));
|
||||
#define pre fa[match[i]]
|
||||
int lca,i;
|
||||
for(i = x;i;i = pre){
|
||||
i = base[i];
|
||||
mark[i] = 1;
|
||||
}
|
||||
for(i = y;i; i = pre){
|
||||
i = base[i];
|
||||
if(mark[i]){
|
||||
lca = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
for (i = x; base[i] != lca; i = pre){
|
||||
if(base[pre] != lca) fa[pre] = match[i];
|
||||
in_blossom[base[i]] = 1;
|
||||
in_blossom[base[match[i]]] = 1;
|
||||
}
|
||||
for (i = y; base[i] != lca; i = pre){
|
||||
if (base[pre] != lca) fa[pre] = match[i];
|
||||
in_blossom[base[i]] = 1;
|
||||
in_blossom[base[match[i]]] = 1;
|
||||
}
|
||||
#undef pre
|
||||
if (base[x] != lca) fa[x] = y;
|
||||
if (base[y] != lca) fa[y] = x;
|
||||
for (i = 1; i <= n; ++i){
|
||||
if (in_blossom[base[i]]){
|
||||
base[i] = lca;
|
||||
if (!in_queue[i]){
|
||||
Q[++tail] = i;
|
||||
in_queue[i] = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
inline void Change(){
|
||||
int x,y,z;
|
||||
z = finish;
|
||||
while (z){
|
||||
y = fa[z];
|
||||
x = match[y];
|
||||
match[y] = z;
|
||||
match[z] = y;
|
||||
z = x;
|
||||
}
|
||||
}
|
||||
inline void FindAugmentPath(){
|
||||
memset(fa,0,sizeof(fa));
|
||||
memset(in_queue,0,sizeof(in_queue));
|
||||
for(int i = 1; i <= n; ++i)base[i] = i;
|
||||
head = 0; tail = 1;
|
||||
Q[1] = start;
|
||||
in_queue[start] = 1;
|
||||
while (head != tail){
|
||||
int x = Q[++head];
|
||||
for (int y = 1; y <= n; ++y){
|
||||
if (adj[x][y] && base[x] != base[y] && match[x] != y)
|
||||
if (start == y || match[y] && fa[match[y]])
|
||||
Contract(x,y);
|
||||
else if(!fa[y]){
|
||||
fa[y] = x;
|
||||
if(match[y]){
|
||||
Q[++tail] = match[y];
|
||||
in_queue[match[y]] = 1;
|
||||
}
|
||||
else {
|
||||
finish = y;
|
||||
Change();
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
inline void Edmonds(){
|
||||
memset(match,0,sizeof(match));
|
||||
for (start = 1; start <= n; ++start)
|
||||
if (match[start] == 0)
|
||||
FindAugmentPath();
|
||||
}
|
||||
inline void init(){
|
||||
memset(adj,0,sizeof(adj));
|
||||
}
|
||||
int deg[MAXN], D[MAXN], M;
|
||||
pair<int ,int> edge[MAXN], id[MAXN];
|
||||
int main(){
|
||||
int Case, u, v,V;
|
||||
scanf("%d",&Case);
|
||||
for(int it = 1;it <= Case; ++it){
|
||||
scanf("%d%d",&V,&M);
|
||||
memset(deg, 0, sizeof(deg));
|
||||
memset(adj, 0, sizeof(adj));
|
||||
for(int i = 0;i < M; ++i){
|
||||
scanf("%d%d",&u,&v);
|
||||
u --; v --;
|
||||
edge[i] = make_pair(u, v);
|
||||
deg[u] ++; deg[v] ++;
|
||||
}
|
||||
for(int i = 0;i < V; ++i){
|
||||
scanf("%d",&D[i]);
|
||||
}
|
||||
bool flag = true;
|
||||
int cnt = 1;
|
||||
for(int i = 0;i < MAXN; ++i) id[i] = make_pair(-1, -1);
|
||||
for(int i = 0;i < V; ++i)
|
||||
if(deg[i] < D[i]) { flag = false; break; }
|
||||
printf("Case %d: ",it);
|
||||
if(!flag) {
|
||||
puts("NO");
|
||||
continue;
|
||||
}
|
||||
for(int i = 0;i < M; ++i){
|
||||
u = edge[i].first;
|
||||
v = edge[i].second;
|
||||
if(id[u].first == -1){
|
||||
id[u] = make_pair(cnt, cnt + deg[u] - D[u] - 1);
|
||||
cnt += (deg[u] - D[u]);
|
||||
}
|
||||
if(id[v].first == -1){
|
||||
id[v] = make_pair(cnt, cnt + deg[v] - D[v] - 1);
|
||||
cnt += (deg[v] - D[v]);
|
||||
}
|
||||
if(id[V+i].first == -1){
|
||||
id[V+i] = make_pair(cnt, cnt + 1);
|
||||
cnt += 2;
|
||||
}
|
||||
int t = id[V+i].first;
|
||||
adj[t][t+1] = adj[t+1][t] = true;
|
||||
for(int j = id[u].first;j <= id[u].second; ++j)
|
||||
adj[t][j] = adj[j][t] = true;
|
||||
for(int j = id[v].first;j <= id[v].second; ++j)
|
||||
adj[t+1][j] = adj[j][t+1] = true;
|
||||
}
|
||||
int j, sum = 0;
|
||||
n = cnt-1;
|
||||
flag = 1;
|
||||
Edmonds();
|
||||
for(int i = 1; i <= n; ++i){
|
||||
if(!match[i]){
|
||||
flag = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(flag) puts("YES");
|
||||
else puts("NO");
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
#include <stdio.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
struct TT
|
||||
{
|
||||
int a,b;
|
||||
bool operator <(const TT&s)const
|
||||
{
|
||||
return a > s.a;
|
||||
}
|
||||
}S[100005];
|
||||
int main()
|
||||
{
|
||||
int z,n,ncase=0;
|
||||
scanf("%d",&z);
|
||||
while(z--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
for(int i=1;i<=n;i++)
|
||||
scanf("%d%d",&S[i].a,&S[i].b);
|
||||
sort(S+1,S+1+n);
|
||||
int ans = 0x7fffffff , B = 0;
|
||||
S[n+1].a = 0;
|
||||
for(int i=1;i<=n+1;i++)
|
||||
{
|
||||
B = max(B,S[i-1].b);
|
||||
ans = min(ans,S[i].a+B);
|
||||
}
|
||||
printf("Case %d: %d\n",++ncase,ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,136 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
#define MAXN 100000
|
||||
#define MAXM 128
|
||||
int head[MAXN], succ[MAXN], succRank[MAXN];
|
||||
int sa[MAXN], rank[MAXN];
|
||||
int letter[MAXM];
|
||||
void da(char* str, int len) {
|
||||
memset(letter, 0, sizeof(letter));
|
||||
for (int i = 0; i < len; ++i)
|
||||
if (!letter[str[i]])
|
||||
letter[str[i]] = 1;
|
||||
int total = -1;
|
||||
for (int i = 0; i < MAXM; ++i)
|
||||
if (letter[i])
|
||||
letter[i] = ++total;
|
||||
memset(head, 255, sizeof(head));
|
||||
for (int i = len - 1; i >= 0; --i) {
|
||||
rank[i] = letter[str[i]];
|
||||
succ[i] = head[rank[i]];
|
||||
head[rank[i]] = i;
|
||||
}
|
||||
int j = 0;
|
||||
for (int i = 0; i < len; ++i) {
|
||||
while (head[j] == -1) ++j;
|
||||
sa[i] = head[j];
|
||||
head[j] = succ[head[j]];
|
||||
}
|
||||
for (int k = 1; k < len; k <<= 1) {
|
||||
for (int i = len - 1; i >= 0; --i)
|
||||
if (sa[i] - k >= 0) {
|
||||
succRank[sa[i] - k] = rank[sa[i]];
|
||||
succ[sa[i] - k] = head[rank[sa[i] - k]];
|
||||
head[rank[sa[i] - k]] = sa[i] - k;
|
||||
}
|
||||
for (int i = len - 1; i >= len - k; --i) {
|
||||
succRank[i] = -1;
|
||||
succ[i] = head[rank[i]];
|
||||
head[rank[i]] = i;
|
||||
}
|
||||
j = 0; total = -1;
|
||||
int preSuccRank = 0, preRank = 0;
|
||||
for (int i = 0; i < len; ++i) {
|
||||
while (head[j] == -1) ++j;
|
||||
sa[i] = head[j];
|
||||
if (i == 0 || preRank != rank[sa[i]] || preSuccRank != succRank[sa[i]]) {
|
||||
preRank = rank[sa[i]];
|
||||
rank[sa[i]] = ++total;
|
||||
} else {
|
||||
preRank = rank[sa[i]];
|
||||
rank[sa[i]] = total;
|
||||
}
|
||||
preSuccRank = succRank[sa[i]];
|
||||
head[j] = succ[head[j]];
|
||||
}
|
||||
}
|
||||
}
|
||||
int height[MAXN];
|
||||
long long mem[MAXN + 1], *sumLength = mem + 1;
|
||||
void calcHeight(char* str, int len) {
|
||||
int i, j, k = 0;
|
||||
for (i = 0; i < len; ++i) {
|
||||
if (k != 0)
|
||||
--k;
|
||||
if (rank[i] == 0)
|
||||
continue;
|
||||
j = sa[rank[i] - 1];
|
||||
while (str[i + k] == str[j + k])
|
||||
++k;
|
||||
height[rank[i]] = k;
|
||||
}
|
||||
}
|
||||
int minData[MAXN + 1][18];
|
||||
inline int minHeight(int x, int y) {
|
||||
return height[x] <= height[y] ? x : y;
|
||||
}
|
||||
inline void initRMQ(int s, int e) {
|
||||
if (s > e)
|
||||
return;
|
||||
for (int i = s; i <= e; ++i)
|
||||
minData[i][0] = i;
|
||||
int h = (int)(log(e - s + 1.0) / log(2.0));
|
||||
for (int j = 1; j <= h; ++j)
|
||||
for (int i = s; i + (1 << j) - 1 <= e; ++i)
|
||||
minData[i][j] = minHeight(minData[i][j - 1], minData[i + (1 << (j - 1))][j - 1]);
|
||||
}
|
||||
inline int askRMQ(int a, int b) {
|
||||
int l = (int)(log(b - a + 1.0) / log(2.0));
|
||||
return minHeight(minData[a][l], minData[b - (1 << l) + 1][l]);
|
||||
}
|
||||
inline int lcp(int a, int b) {
|
||||
return height[askRMQ(std::min(rank[a], rank[b]) + 1, std::max(rank[a], rank[b]))];
|
||||
}
|
||||
char buf[MAXN + 2];
|
||||
long long k;
|
||||
int rk, rl;
|
||||
void getAnswer(long long a, long long b) {
|
||||
int h = 0;
|
||||
while (a != b) {
|
||||
int idx = askRMQ(a + 1, b) - 1;
|
||||
if (k <= (height[idx + 1] - h) * (b - a + 1)) {
|
||||
rk = a; rl = h + 1 + (k - 1) / (b - a + 1);
|
||||
return;
|
||||
}
|
||||
k -= (height[idx + 1] - h) * (b - a + 1);
|
||||
if (k <= sumLength[idx] - sumLength[a - 1] - height[idx + 1] * (idx - a + 1)) {
|
||||
b = idx; h = height[idx + 1];
|
||||
continue;
|
||||
}
|
||||
k -= sumLength[idx] - sumLength[a - 1] - height[idx + 1] * (idx - a + 1);
|
||||
a = idx + 1;
|
||||
h = height[idx + 1];
|
||||
}
|
||||
rk = a; rl = h + k;
|
||||
}
|
||||
int main() {
|
||||
int test;
|
||||
scanf("%d", &test);
|
||||
for (int cas = 1; cas <= test; ++cas) {
|
||||
scanf("%s%I64d", buf, &k);
|
||||
int len = strlen(buf);
|
||||
da(buf, len);
|
||||
calcHeight(buf, len);
|
||||
for (int i = 0; i < len; ++i)
|
||||
sumLength[i] = sumLength[i - 1] + len - sa[i];
|
||||
initRMQ(1, len - 1);
|
||||
getAnswer(0, len - 1);
|
||||
printf("Case %d: ", cas);
|
||||
for (int i = 0; i < rl; ++i)
|
||||
putchar(buf[sa[rk] + i]);
|
||||
putchar('\n');
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<cmath>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
int a[1005][1005];
|
||||
int ques[1005];
|
||||
struct mike{
|
||||
int sum,k,num;
|
||||
}b[1005];
|
||||
int n,s,p;
|
||||
bool cmp(mike a,mike b){
|
||||
if(a.sum!=b.sum) return a.sum>b.sum;
|
||||
if(a.num!=b.num) return a.num>b.num;
|
||||
else return a.k<b.k;
|
||||
}
|
||||
int main(){
|
||||
int i,j;
|
||||
while(~scanf("%d%d%d",&n,&s,&p)){
|
||||
memset(ques,0,sizeof(ques));
|
||||
memset(b,0,sizeof(b));
|
||||
for(i=0;i<n;i++){
|
||||
for(j=0;j<s;j++){
|
||||
scanf("%d",&a[i][j]);
|
||||
ques[i]+=a[i][j];
|
||||
b[j].num+=a[i][j];
|
||||
}
|
||||
}
|
||||
for(i=0;i<s;i++){
|
||||
b[i].k=i;
|
||||
for(j=0;j<n;j++)
|
||||
if(a[j][i]){
|
||||
b[i].sum+=s-ques[j];
|
||||
}
|
||||
}
|
||||
sort(b,b+s,cmp);
|
||||
for(i=0;i<s;i++){
|
||||
if(b[i].k==p-1) break;
|
||||
}
|
||||
printf("%d %d\n",b[i].sum,i+1);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
#include<iostream>
|
||||
#include<cstring>
|
||||
#include<cstdio>
|
||||
using namespace std;
|
||||
long long dp[20][3];
|
||||
int digit[20];
|
||||
int main()
|
||||
{
|
||||
memset(dp,0,sizeof(dp));
|
||||
dp[0][0] = 1;
|
||||
for(int i=1; i<20; i++)
|
||||
{
|
||||
dp[i][0] = dp[i-1][0] * 10 - dp[i-1][1];
|
||||
dp[i][1] = dp[i-1][0];
|
||||
dp[i][2] = dp[i-1][2] * 10 + dp[i-1][1];
|
||||
}
|
||||
int t;
|
||||
cin >> t;
|
||||
while(t--)
|
||||
{
|
||||
int len = 0,last=0;
|
||||
long long ans = 0;
|
||||
unsigned long long n=0;
|
||||
cin >> n;
|
||||
n++;
|
||||
memset(digit,0,sizeof(digit));
|
||||
while(n)
|
||||
{
|
||||
digit[++len] = n%10;
|
||||
n/=10;
|
||||
}
|
||||
bool flag = false;
|
||||
for(int i =len; i>=1; i--)
|
||||
{
|
||||
ans += dp[i-1][2] * digit[i];
|
||||
if(flag)
|
||||
ans += dp[i-1][0] * digit[i];
|
||||
if(!flag && digit[i] >4)
|
||||
ans += dp[i-1][1];
|
||||
if(last == 4 && digit[i] == 9)
|
||||
flag = true;
|
||||
last = digit[i];
|
||||
}
|
||||
cout << ans << endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,59 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include <algorithm>
|
||||
#define MAX 10002
|
||||
#define PUTS(M,x) for(int k=0;k<M;k++) putchar(x)
|
||||
#define ll long long
|
||||
using namespace std;
|
||||
char c[MAX];
|
||||
int l;
|
||||
ll a[MAX];
|
||||
char ss[MAX<<4][20];
|
||||
int len[MAX];
|
||||
int tot;
|
||||
typedef struct{
|
||||
ll fz,fm;
|
||||
}fs;
|
||||
fs A[3],p;
|
||||
void cons(int l){
|
||||
if(c[0]=='L'){
|
||||
a[0]=0; a[1]=2; tot=1;
|
||||
}else{
|
||||
a[0]=2; tot=0;
|
||||
}
|
||||
for(int i=1;i<l;i++){
|
||||
if(c[i]==c[i-1]) a[tot]++;
|
||||
else{
|
||||
a[tot]--;
|
||||
a[++tot]=2;
|
||||
}
|
||||
}
|
||||
tot++;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int M;
|
||||
while(scanf("%s",c)!=EOF){
|
||||
l=strlen(c);
|
||||
cons(l);
|
||||
for(int i=0;i<tot;i++) sprintf(ss[i],"%I64d",a[i]);
|
||||
len[tot-1]=strlen(ss[tot-1]);
|
||||
len[tot-2]=strlen(ss[tot-2]) + 3 + strlen(ss[tot-1]);
|
||||
for(int i=tot-3;i>=0;i--){
|
||||
len[i]=strlen(ss[i]) + 3 + len[i+1];
|
||||
}
|
||||
M=len[0];
|
||||
for(int i=0;i<tot-1;i++){
|
||||
PUTS(M-1,' '); putchar('1'); putchar('\n');
|
||||
PUTS(M-len[i],' ');
|
||||
printf("%s + ",ss[i]);
|
||||
PUTS(len[i+1],'-');
|
||||
putchar('\n');
|
||||
}
|
||||
PUTS(M-(int)strlen(ss[tot-1]),' ');
|
||||
printf("%s",ss[tot-1]);
|
||||
printf("\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
#include <cstdio>
|
||||
#include <cmath>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define N 50005
|
||||
#define lson l,m,rt<<1
|
||||
#define rson m+1,r,rt<<1|1
|
||||
#define ls rt<<1
|
||||
#define rs rt<<1|1
|
||||
char st[50005];
|
||||
int the[30];
|
||||
int main() {
|
||||
while (~scanf("%s", st)) {
|
||||
memset(the, 0, sizeof(the));
|
||||
int len = strlen(st);
|
||||
bool flag = true;
|
||||
int tot = 0;
|
||||
for (int i = 0; i < len; ) {
|
||||
char ch = st[i];
|
||||
int k = i;
|
||||
while (k < len && ch == st[k]) k++;
|
||||
k = k - i;
|
||||
if (k == 1 || k == 2) tot++;
|
||||
else {
|
||||
int t = 1, x = k;
|
||||
while (x >= 2 * t) {
|
||||
x -= t;
|
||||
tot++; t++;
|
||||
}
|
||||
tot++;
|
||||
}
|
||||
i += k;
|
||||
the[ch - 'A'] += k;
|
||||
}
|
||||
int num = tot;
|
||||
if (st[0] == st[len - 1] && the[st[0] - 'A'] == 2) flag = false;
|
||||
int lim = 2 * tot - 1; tot--;
|
||||
if ((num & 1) && tot <= 0) flag = false;
|
||||
if (!flag) puts("No");
|
||||
else puts("Yes");
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,77 @@
|
|||
#include<stdio.h>
|
||||
#include<math.h>
|
||||
#include<algorithm>
|
||||
#define eps 1e-8
|
||||
#define PI 3.14159265358979323846
|
||||
using namespace std;
|
||||
struct pt
|
||||
{
|
||||
double x, y;
|
||||
double ang;
|
||||
double p;
|
||||
};
|
||||
int n;
|
||||
int idx[1010];
|
||||
pt p[1010];
|
||||
inline double toAng(double a, double b)
|
||||
{
|
||||
double ret = b - a;
|
||||
if (ret > 2*PI - eps)
|
||||
ret -= 2*PI;
|
||||
return ret < -eps ? (ret + 2*PI) : ret;
|
||||
}
|
||||
bool cmp(int a, int b)
|
||||
{
|
||||
return p[a].ang < p[b].ang;
|
||||
}
|
||||
double calc(int a)
|
||||
{
|
||||
if (p[a].p < eps)
|
||||
return 0.0;
|
||||
double tp = 0.0;
|
||||
int m = n - 1;
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
if (i != a)tp += log(1.0 - p[i].p);
|
||||
p[i].ang = (i == a) ? 10.0 : atan2(p[i].y - p[a].y, p[i].x - p[a].x);
|
||||
}
|
||||
sort(idx, idx + n, cmp);
|
||||
double noP = 0.0, ret = 0.0;
|
||||
int r = 0;
|
||||
for (int i = 0; i < n - 1; i++)
|
||||
{
|
||||
while (r - i < m && toAng(p[idx[i]].ang, p[idx[r%m]].ang) < PI)
|
||||
{
|
||||
noP += log(1.0 - p[idx[r%m]].p);
|
||||
r++;
|
||||
}
|
||||
noP -= log(1.0 - p[idx[i]].p);
|
||||
ret += p[idx[i]].p * exp(noP);
|
||||
}
|
||||
return p[a].p * (ret + exp(tp));
|
||||
}
|
||||
double solve()
|
||||
{
|
||||
if (n == 1)
|
||||
return p[0].p;
|
||||
double ans = 0.0;
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
ans += calc(i);
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while (~scanf("%d", &n))
|
||||
{
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
scanf("%lf %lf %lf", &p[i].x, &p[i].y, &p[i].p);
|
||||
p[i].p /= 100.0;
|
||||
idx[i] = i;
|
||||
}
|
||||
printf("%.2lf\n", solve());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,98 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#define MAXD 7776
|
||||
double f[MAXD][5], a[MAXD];
|
||||
int vis[MAXD][5];
|
||||
int N, D, limit[5], code[5], q[5];
|
||||
const int M = 7776;
|
||||
struct Point
|
||||
{
|
||||
int x, y;
|
||||
}p[5];
|
||||
int sqr(int x)
|
||||
{
|
||||
return x * x;
|
||||
}
|
||||
int dis(Point x, Point y)
|
||||
{
|
||||
return sqr(x.x - y.x) + sqr(x.y - y.y);
|
||||
}
|
||||
void init()
|
||||
{
|
||||
int i;
|
||||
for(i = 0; i < 5; i ++) scanf("%d%d", &p[i].x, &p[i].y);
|
||||
for(i = 0; i < 5; i ++) scanf("%d", &limit[i]);
|
||||
}
|
||||
int encode(int *code)
|
||||
{
|
||||
int i, ans = 0;
|
||||
for(i = 0; i < 5; i ++) ans = ans * 6 + code[i];
|
||||
return ans;
|
||||
}
|
||||
void decode(int st)
|
||||
{
|
||||
for(int i = 4; i >= 0; i --) code[i] = st % 6, st /= 6;
|
||||
}
|
||||
void count(double p)
|
||||
{
|
||||
for(int i = 0; i < 5; i ++) if(code[i] == limit[i]) a[i] += p;
|
||||
}
|
||||
int chains()
|
||||
{
|
||||
int i, n = 0;
|
||||
for(i = 0; i < 5; i ++) n += code[i];
|
||||
return n;
|
||||
}
|
||||
void solve()
|
||||
{
|
||||
int i, j, k, x, st, t, n;
|
||||
memset(a, 0, sizeof(a));
|
||||
memset(code, 0, sizeof(code));
|
||||
memset(vis, 0, sizeof(vis));
|
||||
memset(f, 0, sizeof(f));
|
||||
for(i = 0; i < 5; i ++)
|
||||
{
|
||||
code[i] = 1;
|
||||
st = encode(code);
|
||||
vis[st][i] = 1, f[st][i] = 0.2;
|
||||
code[i] = 0;
|
||||
}
|
||||
for(i = 0; i < M; i ++)
|
||||
for(j = 0; j < 5; j ++)
|
||||
if(vis[i][j])
|
||||
{
|
||||
decode(i);
|
||||
if(chains() > N)
|
||||
{
|
||||
vis[i][j] = -1;
|
||||
continue;
|
||||
}
|
||||
n = 0;
|
||||
for(k = 0; k < 5; k ++)
|
||||
if(k != j && code[k] < limit[k] && dis(p[j], p[k]) <= D * D) q[n ++] = k;
|
||||
if(n == 0) vis[i][j] = -1;
|
||||
for(k = 0; k < n; k ++)
|
||||
{
|
||||
x = q[k];
|
||||
++ code[x];
|
||||
st = encode(code);
|
||||
vis[st][x] = 1, f[st][x] += f[i][j] / n;
|
||||
-- code[x];
|
||||
}
|
||||
}
|
||||
for(i = 0; i < M; i ++)
|
||||
for(j = 0; j < 5; j ++)
|
||||
if(vis[i][j] == -1) decode(i), count(f[i][j]);
|
||||
printf("%.3f", a[0]);
|
||||
for(i = 1; i < 5; i ++) printf(" %.3f", a[i]);
|
||||
printf("\n");
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d%d", &N, &D) == 2)
|
||||
{
|
||||
init();
|
||||
solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
const int N=100005;
|
||||
int n,m,pre[N],flag[N],degree[N];
|
||||
int main()
|
||||
{
|
||||
int i;
|
||||
int a,b,t1,tt1,t2,tt2,f1,f2;
|
||||
int ans1,ans2;
|
||||
while(scanf("%d%d",&n,&m),n||m)
|
||||
{
|
||||
for(i=0;i<n;i++) {degree[i]=flag[i]=0;pre[i]=i;}
|
||||
while(m--)
|
||||
{
|
||||
scanf("%d%d",&a,&b);
|
||||
degree[a]++;
|
||||
degree[b]++;
|
||||
f1=pre[a];
|
||||
f2=pre[b];
|
||||
while(pre[f1]!=f1) f1=pre[f1];
|
||||
while(pre[f2]!=f2) f2=pre[f2];
|
||||
t1=a;
|
||||
t2=b;
|
||||
while(pre[t1]!=f1) {tt1=pre[t1];pre[t1]=f1;t1=tt1;}
|
||||
while(pre[t2]!=f2) {tt2=pre[t2];pre[t2]=f2;t2=tt2;}
|
||||
if(f1==f2) continue;
|
||||
pre[f1]=pre[f2];
|
||||
}
|
||||
ans1=ans2=0;
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
f1=pre[i];
|
||||
while(pre[f1]!=f1) f1=pre[f1];
|
||||
t1=i;
|
||||
while(pre[t1]!=f1) {tt1=pre[t1];pre[t1]=f1;t1=tt1;}
|
||||
if(degree[i]!=2) flag[f1]=1;
|
||||
}
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
if(pre[i]!=i) continue;
|
||||
ans1++;
|
||||
if(!flag[i]) ans2++;
|
||||
}
|
||||
printf("%d %d\n",ans1,ans2);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,88 @@
|
|||
#include<iostream>
|
||||
#include<vector>
|
||||
#include<math.h>
|
||||
using namespace std;
|
||||
#define eps 1e-8
|
||||
const int maxn=105;
|
||||
struct point
|
||||
{
|
||||
double x,y;
|
||||
};
|
||||
struct circle
|
||||
{
|
||||
point p;
|
||||
double r;
|
||||
}c[maxn];
|
||||
vector<point>v;
|
||||
double dis(point p1,point p2)
|
||||
{
|
||||
return sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y));
|
||||
}
|
||||
point intersection(point u1,point u2,point v1,point v2)
|
||||
{
|
||||
point ret=u1;
|
||||
double t=((u1.x-v1.x)*(v1.y-v2.y)-(u1.y-v1.y)*(v1.x-v2.x))/((u1.x-u2.x)*(v1.y-v2.y)-(u1.y-u2.y)*(v1.x-v2.x));
|
||||
ret.x+=(u2.x-u1.x)*t;
|
||||
ret.y+=(u2.y-u1.y)*t;
|
||||
return ret;
|
||||
}
|
||||
int intersect_circle_circle(point c1,double r1,point c2,double r2)
|
||||
{
|
||||
return dis(c1,c2)<r1+r2+eps&&dis(c1,c2)>fabs(r1-r2)-eps;
|
||||
}
|
||||
void intersection_line_circle(point c,double r,point l1,point l2,point &p1,point &p2)
|
||||
{
|
||||
point p=c;
|
||||
double t;
|
||||
p.x+=l1.y-l2.y;
|
||||
p.y+=l2.x-l1.x;
|
||||
p=intersection(p,c,l1,l2);
|
||||
t=sqrt(r*r-dis(p,c)*dis(p,c))/dis(l1,l2);
|
||||
p1.x=p.x+(l2.x-l1.x)*t;
|
||||
p1.y=p.y+(l2.y-l1.y)*t;
|
||||
p2.x=p.x-(l2.x-l1.x)*t;
|
||||
p2.y=p.x-(l2.y-l1.y)*t;
|
||||
}
|
||||
void intersection_circle_circle(point c1,double r1,point c2,double r2,point &p1,point &p2)
|
||||
{
|
||||
point u,v;
|
||||
double t;
|
||||
t=(1+(r1*r1-r2*r2)/dis(c1,c2)/dis(c1,c2))/2;
|
||||
u.x=c1.x+(c2.x-c1.x)*t;
|
||||
u.y=c1.y+(c2.y-c1.y)*t;
|
||||
v.x=u.x+c1.y-c2.y;
|
||||
v.y=u.y-c1.x+c2.x;
|
||||
intersection_line_circle(c1,r1,u,v,p1,p2);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
while(scanf("%d",&n)!=EOF)
|
||||
{
|
||||
int cnt=0;
|
||||
v.clear();
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
cin>>c[i].p.x>>c[i].p.y>>c[i].r;
|
||||
v.push_back(c[i].p);
|
||||
}
|
||||
for(int i=0;i<n;i++)
|
||||
for(int j=0;j<i;j++)
|
||||
if(intersect_circle_circle(c[i].p,c[i].r,c[j].p,c[j].r))
|
||||
{
|
||||
point x,y;
|
||||
intersection_circle_circle(c[i].p, c[i].r, c[j].p, c[j].r, x, y);
|
||||
v.push_back(x);v.push_back(y);
|
||||
}
|
||||
int maxt=-1;
|
||||
for(int i=0;i<v.size();i++)
|
||||
{
|
||||
int cnt=0;
|
||||
for(int j=0;j<n;j++)
|
||||
cnt+=dis(v[i],c[j].p)<c[j].r+eps;
|
||||
maxt=max(cnt,maxt);
|
||||
}
|
||||
cout<<maxt<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
using namespace std;
|
||||
const int maxn=1004;
|
||||
int dp[maxn][maxn];
|
||||
int data[maxn][2];
|
||||
int main(){
|
||||
int n,a,b;
|
||||
while(scanf("%d",&n)!=EOF){
|
||||
memset(dp,0,sizeof(dp));
|
||||
for(int i=4;i<=n;i++){
|
||||
scanf("%d%d",&a,&b);
|
||||
data[i][0]=a;
|
||||
data[i][1]=b;
|
||||
}
|
||||
int ans=0;
|
||||
for(int i=n;i>=4;i--){
|
||||
a=data[i][0];
|
||||
b=data[i][1];
|
||||
ans=max(ans,dp[a][b]+dp[a][i]+dp[i][b]+3);
|
||||
dp[a][b]=dp[b][a]=max(dp[a][b],dp[a][i]+dp[i][b]+1);
|
||||
}
|
||||
printf("%d\n",max(ans,dp[1][2]+dp[2][3]+dp[1][3]+3));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,78 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
int n,s[1000000],dp[1000000],ans[1000000],len;
|
||||
struct node
|
||||
{
|
||||
int l,r,n;
|
||||
} a[1000000];
|
||||
void init(int l,int r,int i)
|
||||
{
|
||||
a[i].l = l;
|
||||
a[i].r = r;
|
||||
if(l == r)
|
||||
{
|
||||
a[i].n = 1;
|
||||
return ;
|
||||
}
|
||||
int mid = (l+r)>>1;
|
||||
init(l,mid,i*2);
|
||||
init(mid+1,r,i*2+1);
|
||||
a[i].n = a[i*2].n+a[i*2+1].n;
|
||||
}
|
||||
void insert(int i,int x,int m)
|
||||
{
|
||||
if(a[i].l == a[i].r)
|
||||
{
|
||||
ans[m] = a[i].l;
|
||||
a[i].n=0;
|
||||
return;
|
||||
}
|
||||
a[i].n--;
|
||||
if(x<=a[2*i].n)
|
||||
insert(2*i,x,m);
|
||||
else
|
||||
insert(2*i+1,x-a[2*i].n,m);
|
||||
}
|
||||
int bin(int k)
|
||||
{
|
||||
int l = 1,r = len;
|
||||
while(l<=r)
|
||||
{
|
||||
int mid = (l+r)>>1;
|
||||
if(k>dp[mid])
|
||||
l = mid+1;
|
||||
else
|
||||
r = mid-1;
|
||||
}
|
||||
return l;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t,i,j,cas = 1;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
for(i = 1; i<=n; i++)
|
||||
{
|
||||
scanf("%d",&s[i]);
|
||||
dp[i] = 0;
|
||||
}
|
||||
init(1,n,1);
|
||||
printf("Case #%d:\n",cas++);
|
||||
for(i = n; i>0; i--)
|
||||
insert(1,s[i]+1,i);
|
||||
len = 0;
|
||||
for(i = 1; i<=n; i++)//LIS()
|
||||
{
|
||||
int k = bin(ans[i]);
|
||||
len = max(len,k);
|
||||
dp[k] = ans[i];
|
||||
printf("%d\n",len);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,90 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <iostream>
|
||||
#define N 35
|
||||
#define OVER 7
|
||||
typedef unsigned long long ll;
|
||||
using namespace std;
|
||||
char B[N];
|
||||
char A[N];
|
||||
int dp[N][10][OVER+1];
|
||||
int next(int now,int p,int q)
|
||||
{
|
||||
switch(now)
|
||||
{
|
||||
case 0:return p>0?1:OVER;
|
||||
case 1:return p>0?1:p<0?2:OVER;
|
||||
case 2:return p<0?3:q?4:OVER;
|
||||
case 3:return p<0?3:p&&q-p?5:q?4:OVER;
|
||||
case 4:return p>0?5:OVER;
|
||||
case 5:return p<0?6:p>0?5:OVER;
|
||||
case 6:return p<0?6:OVER;
|
||||
default:return OVER;
|
||||
}
|
||||
}
|
||||
void DP()
|
||||
{
|
||||
memset(dp,128,sizeof(dp));
|
||||
for(int i = 0 ; i < 10 ; i++)
|
||||
dp[0][i][OVER-1] = i;
|
||||
for(int i = 1 ; i < N ; i++)
|
||||
for(int j = 0 ; j < 10 ; j++)
|
||||
for(int l = 0 ; l < OVER ; l++)
|
||||
for(int k = 0 ; k < 10 ; k++)
|
||||
dp[i][j][l] = max(dp[i][j][l] , dp[i-1][k][next(l,k-j,k)]+j);
|
||||
}
|
||||
int find(ll a,ll b)
|
||||
{
|
||||
sprintf(B,"%I64u",b);
|
||||
int len = strlen(B);
|
||||
sprintf(A,"%0*I64u",len--,a);
|
||||
int ii,sum = 0,now;
|
||||
for(ii = 0 ; A[ii] && A[ii]==B[ii] ; ii++)
|
||||
{
|
||||
now = !ii ? 0 : next(now,A[ii]-A[ii-1],A[ii]-'0');
|
||||
sum += A[ii]-'0';
|
||||
}
|
||||
int tsum = sum, tnow = now, ans = 0;
|
||||
for(int i = ii; B[i] ; i++)
|
||||
{
|
||||
for( int j = i==ii? A[i] - '0' + 1 : 0 ; j < B[i] - '0' ; j++)
|
||||
ans = max(ans,dp[len-i][j][!i ? 0 : next(now,j-B[i-1]+'0',j)]+sum);
|
||||
now = !i ? 0 : next(now,B[i]-B[i-1],B[i]-'0');
|
||||
sum += B[i]-'0';
|
||||
}
|
||||
if(!ii)
|
||||
{
|
||||
while(A[ii]=='0')
|
||||
{
|
||||
ii++;
|
||||
if(!A[ii])return ans;
|
||||
for(int i = A[ii]=='0'?1:A[ii]-'0'+1 ; i < 10 ; i++)
|
||||
ans = max(ans,dp[len-ii][i][0]);
|
||||
}
|
||||
now = 0;
|
||||
}else now = next(tnow,A[ii]-A[ii-1],A[ii]-'0');
|
||||
sum = tsum + A[ii] - '0';
|
||||
for(int i = ++ii;A[i]; i++)
|
||||
{
|
||||
for( int j = A[i] - '0' + 1 ; j < 10 ; j++)
|
||||
ans = max(ans,dp[len-i][j][next(now,j-A[i-1]+'0',j)]+sum);
|
||||
now = next(now,A[i]-A[i-1],A[i]-'0');
|
||||
sum += A[i] - '0';
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t,cas = 1;
|
||||
ll a,b;
|
||||
scanf("%d",&t);
|
||||
DP();
|
||||
while(t--)
|
||||
{
|
||||
scanf("%I64u %I64u",&a,&b);
|
||||
if(!a)a++;
|
||||
if(!(b+1))b--;
|
||||
printf("Case %d: %d\n",cas++,find(a-1,b+1));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,169 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <cstdlib>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <queue>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
using namespace std;
|
||||
#define LL __int64
|
||||
const int maxn=4e5+10;
|
||||
const int INF=1e8;
|
||||
int ha[9]={1,1,2,6,24,120,720,5040,40320};
|
||||
int dir[4][2]={{1,0},{0,-1},{0,1},{-1,0}};
|
||||
char d[10]={"dlru"};
|
||||
LL dd[2][4]={{0,1,2,3},{3,2,1,0}};
|
||||
int vis[2][maxn],t,Min_ans;
|
||||
char ans[maxn],get[maxn];
|
||||
LL c[2][maxn];
|
||||
LL mm[30];
|
||||
struct node{
|
||||
int f[3][3];
|
||||
int x,y;
|
||||
int g;
|
||||
int flag;
|
||||
LL path;
|
||||
int hash_num;
|
||||
};
|
||||
int get_hash(node e)
|
||||
{
|
||||
int a[9],i,j,ii,jj,k=0,ans=0;
|
||||
for(i=0;i<3;i++)
|
||||
{
|
||||
for(j=0;j<3;j++)
|
||||
a[k++]=e.f[i][j];
|
||||
}
|
||||
for(i=0;i<9;i++)
|
||||
{
|
||||
k=0;
|
||||
for(j=0;j<i;j++)
|
||||
if(a[j]>a[i])k++;
|
||||
ans+=ha[i]*k;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
string get_str(LL c,int flag,int kk)
|
||||
{
|
||||
int str[100];
|
||||
int i,j,k=0;
|
||||
for(i=0;i<vis[flag][kk];i++)
|
||||
{
|
||||
str[k++]=c%4;
|
||||
c=c/4;
|
||||
}
|
||||
string s="";
|
||||
for(i=k-1;i>=0;i--)
|
||||
s+=d[str[i]];
|
||||
return s;
|
||||
}
|
||||
void bfs(node e,node ee)
|
||||
{
|
||||
memset(vis,-1,sizeof(vis));
|
||||
int i,j,k,xx,yy,dis[2];
|
||||
dis[0]=dis[1]=0;
|
||||
node a,b;
|
||||
e.hash_num=get_hash(e);
|
||||
e.g=0,e.flag=0;
|
||||
e.path=0;
|
||||
ee.hash_num=get_hash(ee);
|
||||
ee.g=0,ee.flag=1;
|
||||
ee.path=0;
|
||||
vis[0][e.hash_num]=0;
|
||||
vis[1][ee.hash_num]=0;
|
||||
if(e.hash_num==ee.hash_num){printf("0\n\n");return;}
|
||||
queue<node>q;
|
||||
q.push(e);
|
||||
q.push(ee);
|
||||
Min_ans=INF;
|
||||
LL str;
|
||||
string res;
|
||||
while(!q.empty())
|
||||
{
|
||||
e=q.front();
|
||||
q.pop();
|
||||
for(i=0;i<4;i++)
|
||||
{
|
||||
a=e;
|
||||
a.x=e.x+dir[i][0];
|
||||
a.y=e.y+dir[i][1];
|
||||
if(a.x<0||a.y<0||a.x>=3||a.y>=3)continue;
|
||||
swap(a.f[e.x][e.y],a.f[a.x][a.y]);
|
||||
k=get_hash(a);
|
||||
if(vis[e.flag][k]!=-1)
|
||||
{
|
||||
if(e.g+1>vis[e.flag][k])continue;
|
||||
else
|
||||
{
|
||||
if(e.flag)str=dd[e.flag][i]*mm[e.g]+e.path;
|
||||
else str=e.path*4+dd[e.flag][i];
|
||||
if(c[e.flag][k]>str)
|
||||
c[e.flag][k]=str;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
vis[e.flag][k]=e.g+1;
|
||||
if(e.flag)c[e.flag][k]=dd[e.flag][i]*mm[e.g]+e.path;
|
||||
else c[e.flag][k]=e.path*4+dd[e.flag][i];
|
||||
}
|
||||
a.hash_num=k;
|
||||
a.g++;
|
||||
a.path=c[e.flag][k];
|
||||
if(vis[e.flag^1][k]!=-1)
|
||||
{
|
||||
string s=get_str(c[0][k],0,k)+get_str(c[1][k],1,k);
|
||||
t=s.length();
|
||||
if(t>Min_ans)
|
||||
{
|
||||
cout<<Min_ans<<endl;
|
||||
cout<<res<<endl;
|
||||
return;
|
||||
}
|
||||
if(t<Min_ans)
|
||||
{
|
||||
Min_ans=t;
|
||||
res=s;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(res.compare(s)>0)res=s;
|
||||
}
|
||||
}
|
||||
q.push(a);
|
||||
}
|
||||
}
|
||||
}
|
||||
void init()
|
||||
{
|
||||
int i,j,k;
|
||||
mm[0]=1;
|
||||
for(i=1;i<=30;i++)
|
||||
mm[i]=mm[i-1]*4;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
init();
|
||||
char a[30],b[30];
|
||||
int T,tt=0;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
int i,j,k,n;
|
||||
node e,pp;
|
||||
scanf("%s",a);
|
||||
scanf("%s",b);
|
||||
n=strlen(a);
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
if(a[i]=='X'){e.f[i/3][i%3]=0;e.x=i/3;e.y=i%3;}
|
||||
else e.f[i/3][i%3]=a[i]-'0';
|
||||
if(b[i]=='X'){pp.f[i/3][i%3]=0;pp.x=i/3;pp.y=i%3;}
|
||||
else pp.f[i/3][i%3]=b[i]-'0';
|
||||
}
|
||||
printf("Case %d: ",++tt);
|
||||
bfs(e,pp);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<iostream>
|
||||
using namespace std;
|
||||
#define maxn 100005
|
||||
#define ll __int64
|
||||
ll x[maxn],y[maxn];
|
||||
ll sumx[maxn],sumy[maxn];
|
||||
int main(){
|
||||
ll i,j,k,T,n,C=1;
|
||||
scanf("%I64d",&T);
|
||||
while(T--){
|
||||
scanf("%I64d",&n);
|
||||
memset(sumx,0,sizeof(sumx));
|
||||
memset(sumy,0,sizeof(sumy));
|
||||
for(i=1;i<=n;i++){
|
||||
scanf("%I64d%I64d",&x[i],&y[i]);
|
||||
sumx[i]=sumx[i-1]+x[i];
|
||||
sumy[i]=sumy[i-1]+y[i];
|
||||
}
|
||||
ll sum=0;
|
||||
for(i=1;i<=n;i++){
|
||||
sum+=sumx[i-1]*y[i]+sumy[i-1]*x[i];
|
||||
}
|
||||
printf("Case %I64d: %I64d\n",C++,sum);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
#include <iostream>
|
||||
#include <string>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define N 1010
|
||||
#define min(a,b)a>b?b:a
|
||||
int n;
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
int i,j,n,m,k,a[N],b;
|
||||
for(i=1;i<=T;i++)
|
||||
{
|
||||
scanf("%d%d%d",&n,&m,&k);
|
||||
double ans=0;
|
||||
double sum=0;
|
||||
for(j=1;j<=n;j++)
|
||||
{
|
||||
scanf("%d",&a[j]);
|
||||
sum+=a[j];
|
||||
}
|
||||
if(k<=n)
|
||||
ans=sum*1.0*m/n;
|
||||
else
|
||||
{
|
||||
ans+=m/k*sum;
|
||||
if(m%k<n)
|
||||
ans+=sum/n*(m%k);
|
||||
else
|
||||
ans+=n;
|
||||
}
|
||||
printf("Case %d: %.5lf\n",i,ans*1.0);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,99 @@
|
|||
#include <vector>
|
||||
#include <list>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <deque>
|
||||
#include <stack>
|
||||
#include <bitset>
|
||||
#include <algorithm>
|
||||
#include <functional>
|
||||
#include <numeric>
|
||||
#include <utility>
|
||||
#include <sstream>
|
||||
#include <iostream>
|
||||
#include <iomanip>
|
||||
#include <cstdio>
|
||||
#include <cmath>
|
||||
#include <cstdlib>
|
||||
#include <ctime>
|
||||
#include <cstring>
|
||||
#include <queue>
|
||||
using namespace std;
|
||||
const int MAXN = 210;
|
||||
const int INFINITE = 0x3F3F3F3F ;
|
||||
int dp[MAXN] , f0[MAXN][MAXN] , f1[MAXN][MAXN] , f2[MAXN][MAXN] , n , m , p ;
|
||||
vector< pair<int , int> > e[MAXN] ;
|
||||
int tot[MAXN] ;
|
||||
void dfs(int u,int fa)
|
||||
{
|
||||
tot[u] = 1 ;
|
||||
for (int i = 0 ; i < e[u].size() ; i++)
|
||||
{
|
||||
int v = e[u][i].first ;
|
||||
if (v == fa) continue ;
|
||||
dfs(v,u) ;
|
||||
tot[u] += tot[v] ;
|
||||
}
|
||||
f0[u][1] = f1[u][1] = f2[u][1] = 0 ;
|
||||
for (int i = 2 ; i <= tot[u] ; i++)
|
||||
f0[u][i] = f1[u][i] = f2[u][i] = INFINITE ;
|
||||
for (int i = 0 ; i < e[u].size() ; i++)
|
||||
{
|
||||
int v = e[u][i].first , w = e[u][i].second ;
|
||||
if (v == fa) continue ;
|
||||
for (int j = tot[u] ; j > 1 ; j--)
|
||||
{
|
||||
for (int k = 1 ; k < j && k <= tot[v] ; k++)
|
||||
{
|
||||
f2[u][j] = min(f2[u][j] , f2[u][j-k] + f2[v][k] + 2 * w) ;
|
||||
f1[u][j] = min(f1[u][j] , f2[u][j-k] + f1[v][k] + w) ;
|
||||
f1[u][j] = min(f1[u][j] , f1[u][j-k] + f2[v][k] + 2 * w) ;
|
||||
f0[u][j] = min(f0[u][j] , f1[u][j-k] + f1[v][k] + w) ;
|
||||
f0[u][j] = min(f0[u][j] , f2[u][j-k] + f0[v][k] + 2 * w) ;
|
||||
f0[u][j] = min(f0[u][j] , f0[u][j-k] + f2[v][k] + 2 * w) ;
|
||||
}
|
||||
}
|
||||
}
|
||||
for (int i = 1 ; i <= tot[u] ; i++)
|
||||
{
|
||||
dp[i] = min(dp[i] , f0[u][i]) ;
|
||||
dp[i] = min(dp[i] , f1[u][i]) ;
|
||||
dp[i] = min(dp[i] , f2[u][i]) ;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T , cas=0 ;
|
||||
scanf("%d",&T);
|
||||
while (T--)
|
||||
{
|
||||
scanf("%d%d",&n,&p);
|
||||
for (int i = 1 ; i <= n ; i++)
|
||||
e[i].clear() ;
|
||||
for (int i = 1 ; i < n ; i++)
|
||||
{
|
||||
int u , v , w ;
|
||||
scanf("%d%d%d",&u,&v,&w);
|
||||
e[u].push_back(make_pair(v,w)) ;
|
||||
e[v].push_back(make_pair(u,w)) ;
|
||||
}
|
||||
for (int i = 1 ; i <= n ; i++)
|
||||
dp[i] = INFINITE ;
|
||||
dfs(1,-1) ;
|
||||
scanf("%d",&m);
|
||||
printf("Case %d:\n",++cas) ;
|
||||
while (m--)
|
||||
{
|
||||
int X ;
|
||||
scanf("%d",&X) ;
|
||||
int ans = 0 ;
|
||||
for (int i = 1 ; i <= n ; i++)
|
||||
{
|
||||
if (dp[i] + i*X > p) break ;
|
||||
ans = i ;
|
||||
}
|
||||
printf("%d\n",ans) ;
|
||||
}
|
||||
}
|
||||
return 0 ;
|
||||
}
|
||||
|
|
@ -0,0 +1,113 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
typedef long long LL;
|
||||
#define MAXN 60
|
||||
#define P 200000000000000003LL
|
||||
#define S 100000000000000000LL
|
||||
using namespace std;
|
||||
LL x[MAXN], g[MAXN][MAXN], a[MAXN][MAXN], b[MAXN][MAXN];
|
||||
int n;
|
||||
inline LL Mod(LL x) {
|
||||
if (x >= P)
|
||||
return x - P;
|
||||
return x;
|
||||
}
|
||||
LL MulMod(LL a, LL b) {
|
||||
LL res;
|
||||
for (res = 0; b; b >>= 1) {
|
||||
if (b & 1)
|
||||
res = Mod(res + a);
|
||||
a = Mod(a + a);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
LL ExtGcd(LL a, LL b, LL &x, LL &y) {
|
||||
if (b == 0) {
|
||||
x = 1;
|
||||
y = 0;
|
||||
return a;
|
||||
}
|
||||
LL t, d;
|
||||
d = ExtGcd(b, a % b, x, y);
|
||||
t = x;
|
||||
x = y;
|
||||
y = t - a / b * y;
|
||||
return d;
|
||||
}
|
||||
LL InvMod(LL a, LL n) {
|
||||
LL x, y;
|
||||
ExtGcd(a, n, x, y);
|
||||
return (x % n + n) % n;
|
||||
}
|
||||
void Gauss() {
|
||||
int i, j, k;
|
||||
LL inv, tmp;
|
||||
for (i = 0; i < n; i++) {
|
||||
for (j = i; j < n; j++) {
|
||||
if (g[j][i])
|
||||
break;
|
||||
}
|
||||
if (i != j) {
|
||||
for (k = i; k <= n; k++)
|
||||
swap(g[i][k], g[j][k]);
|
||||
}
|
||||
inv = InvMod(g[i][i], P);
|
||||
for (j = i + 1; j < n; j++) {
|
||||
if (g[j][i]) {
|
||||
tmp = MulMod(g[j][i], inv);
|
||||
for (k = i; k <= n; k++) {
|
||||
g[j][k] -= MulMod(tmp, g[i][k]);
|
||||
g[j][k] = (g[j][k] % P + P) % P;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for (i = n - 1; i >= 0; i--) {
|
||||
tmp = 0;
|
||||
for (j = i + 1; j < n; j++) {
|
||||
tmp += MulMod(x[j], g[i][j]);
|
||||
if (tmp >= P)
|
||||
tmp -= P;
|
||||
}
|
||||
tmp = g[i][n] - tmp;
|
||||
tmp = (tmp % P + P) % P;
|
||||
x[i] = MulMod(tmp, InvMod(g[i][i], P));
|
||||
}
|
||||
}
|
||||
int main() {
|
||||
int c, ca = 1;
|
||||
int i, j;
|
||||
LL tmp;
|
||||
scanf("%d", &c);
|
||||
while (c--) {
|
||||
scanf("%d", &n);
|
||||
memset(g, 0, sizeof(g));
|
||||
memset(b, 0, sizeof(b));
|
||||
for (i = 0; i <= n; i++) {
|
||||
for (j = 0; j < n; j++) {
|
||||
scanf("%I64d", &a[i][j]);
|
||||
a[i][j] += S;
|
||||
b[i][n] += MulMod(a[i][j], a[i][j]);
|
||||
if (b[i][n] >= P)
|
||||
b[i][n] -= P;
|
||||
}
|
||||
}
|
||||
for (i = 0; i < n; i++) {
|
||||
for (j = 0; j < n; j++) {
|
||||
tmp = a[i + 1][j] - a[i][j];
|
||||
tmp = (tmp % P + P) % P;
|
||||
g[i][j] = MulMod(tmp, 2);
|
||||
}
|
||||
g[i][n] = b[i + 1][n] - b[i][n];
|
||||
g[i][n] = (g[i][n] % P + P) % P;
|
||||
}
|
||||
Gauss();
|
||||
printf("Case %d:\n", ca++);
|
||||
printf("%I64d", x[0] - S);
|
||||
for (i = 1; i < n; i++)
|
||||
printf(" %I64d", x[i] - S);
|
||||
putchar('\n');
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,94 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
#define MAXM 555555
|
||||
#define MAXN 2222
|
||||
struct Edge{
|
||||
int v,cap,next;
|
||||
}edge[MAXM];
|
||||
int pre[MAXN];
|
||||
int cur[MAXN];
|
||||
int head[MAXN];
|
||||
int level[MAXN];
|
||||
int gap[MAXN];
|
||||
int n,m;
|
||||
int NV,NE;
|
||||
int SAP(int vs,int vt){
|
||||
memset(pre,-1,sizeof(pre));
|
||||
memset(level,0,sizeof(level));
|
||||
memset(gap,0,sizeof(gap));
|
||||
for(int i=0;i<=NV;i++)cur[i]=head[i];
|
||||
int u=pre[vs]=vs,maxflow=0,aug=-1;
|
||||
gap[0]=NV;
|
||||
while(level[vs]<NV){
|
||||
loop:
|
||||
for(int &i=cur[u];i!=-1;i=edge[i].next){
|
||||
int v=edge[i].v;
|
||||
if(edge[i].cap&&level[u]==level[v]+1){
|
||||
aug==-1?aug=edge[i].cap:(aug=min(aug,edge[i].cap));
|
||||
pre[v]=u;
|
||||
u=v;
|
||||
if(v==vt){
|
||||
maxflow+=aug;
|
||||
for(u=pre[u];v!=vs;v=u,u=pre[u]){
|
||||
edge[cur[u]].cap-=aug;
|
||||
edge[cur[u]^1].cap+=aug;
|
||||
}
|
||||
aug=-1;
|
||||
}
|
||||
goto loop;
|
||||
}
|
||||
}
|
||||
int minlevel=NV;
|
||||
for(int i=head[u];i!=-1;i=edge[i].next){
|
||||
int v=edge[i].v;
|
||||
if(edge[i].cap&&minlevel>level[v]){
|
||||
cur[u]=i;
|
||||
minlevel=level[v];
|
||||
}
|
||||
}
|
||||
gap[level[u]]--;
|
||||
if(gap[level[u]]==0)break;
|
||||
level[u]=minlevel+1;
|
||||
gap[level[u]]++;
|
||||
u=pre[u];
|
||||
}
|
||||
return maxflow;
|
||||
}
|
||||
void Insert(int u,int v,int cap,int cc=0){
|
||||
edge[NE].cap=cap;edge[NE].v=v;
|
||||
edge[NE].next=head[u];head[u]=NE++;
|
||||
edge[NE].cap=cc;edge[NE].v=u;
|
||||
edge[NE].next=head[v];head[v]=NE++;
|
||||
}
|
||||
int main(){
|
||||
int _case,t=1,vs,vt,st,ed,p,dmax,sum;
|
||||
scanf("%d",&_case);
|
||||
while(_case--){
|
||||
scanf("%d%d",&n,&m);
|
||||
memset(head,-1,sizeof(head));
|
||||
NE=0,dmax=0,vs=0,sum=0;
|
||||
for(int i=1;i<=n;i++){
|
||||
scanf("%d%d%d",&p,&st,&ed);
|
||||
dmax=max(dmax,ed);
|
||||
sum+=p;
|
||||
Insert(vs,i,p);
|
||||
for(int j=st;j<=ed;j++){
|
||||
Insert(i,n+j,1);
|
||||
}
|
||||
}
|
||||
vt=n+dmax+1;
|
||||
for(int i=1;i<=dmax;i++){
|
||||
Insert(n+i,vt,m);
|
||||
}
|
||||
NV=vt+1;
|
||||
printf("Case %d: ",t++);
|
||||
if(sum==SAP(vs,vt)){
|
||||
puts("Yes");
|
||||
}else
|
||||
puts("No");
|
||||
puts("");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
#include<stdio.h>
|
||||
#include<iostream>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
int a,b,c;
|
||||
int iCase=0;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
iCase++;
|
||||
scanf("%d%d%d",&a,&b,&c);
|
||||
int res;
|
||||
if((b+c)*2>=a) res=a/2+(b+c-a/2+a%2+1)/2;
|
||||
else res=(b+c)+(a-(b+c)*2+2)/3;
|
||||
printf("Case %d: %d\n",iCase,res);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,65 @@
|
|||
#include<iostream>
|
||||
#include<string>
|
||||
#include<cstdio>
|
||||
#include<cstdlib>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
int m,n;
|
||||
char digit[1500][1500];
|
||||
void f(int row)
|
||||
{
|
||||
int i,j,k;
|
||||
int len = strlen(digit[row]);
|
||||
for(i=0; i*(m+2)+i-1<len; i++)
|
||||
{
|
||||
if(i != 0)
|
||||
printf(" ");
|
||||
printf(" ");
|
||||
for(j=0; j<n; j++)
|
||||
if(digit[row][(m+2)*i+i+1] == '-')
|
||||
printf("-");
|
||||
else printf(" ");
|
||||
printf(" ");
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
void g(int row)
|
||||
{
|
||||
int i,j,k;
|
||||
int len = strlen(digit[row]);
|
||||
for(i=0; i*(m+2)+i-1<len; i++)
|
||||
{
|
||||
if(i != 0)
|
||||
printf(" ");
|
||||
printf("%c", digit[row][(m+2)*i+i]);
|
||||
for(j=0; j<n; j++)
|
||||
printf(" ");
|
||||
printf("%c", digit[row][i*(m+2)+i+m+1]);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int cases, t;
|
||||
int i,j,k;
|
||||
scanf("%d", &cases);
|
||||
t = 1;
|
||||
while(t <= cases)
|
||||
{
|
||||
scanf("%d %d", &m, &n);
|
||||
getchar();
|
||||
for(i=0; i<2*m+3; i++)
|
||||
gets(digit[i]);
|
||||
printf("Case %d:\n", t);
|
||||
f(0);
|
||||
for(i=0; i<n; i++)
|
||||
g(1);
|
||||
f(m+1);
|
||||
for(i=0; i<n; i++)
|
||||
g(m+2);
|
||||
f(2*m+2);
|
||||
t++;
|
||||
printf("\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#define size 20
|
||||
#define inf 100000000
|
||||
int c,m,n1,n2,n3,t,s,temp;
|
||||
int num[size];
|
||||
int dp[size][size][size][size];
|
||||
int main()
|
||||
{
|
||||
scanf("%d",&t);
|
||||
int T=0;
|
||||
while(t--)
|
||||
{
|
||||
T++;
|
||||
scanf("%d%d",&c,&m);
|
||||
memset(num,0,sizeof(num));
|
||||
memset(dp,-1,sizeof(dp));
|
||||
dp[1][0][0][0]=0;
|
||||
for(int i=0;i<m;i++)
|
||||
{
|
||||
scanf("%d",&s);
|
||||
num[s]++;
|
||||
}
|
||||
for(int i=2;i<=16;i++)
|
||||
for(int j=0;j<=c;j++)
|
||||
for(int k=0;k<=c;k++)
|
||||
for(int l=0;l<=c;l++)
|
||||
{
|
||||
if(dp[i-1][j][k][l] == -1) continue;
|
||||
for(int n1=0;n1<=num[i];n1++)
|
||||
for(int n2=0;n2<=num[i];n2++)
|
||||
{
|
||||
int sum=0;
|
||||
n3=num[i]-(n1+n2);
|
||||
if(n3<0) continue;
|
||||
if(j+n1>c||k+n2>c||l+n3>c) continue;
|
||||
temp = dp[i-1][j][k][l]+(n1!=0)+(n2!=0)+(n3!=0);
|
||||
if(dp[i][j+n1][k+n2][l+n3]==-1||dp[i][j+n1][k+n2][l+n3]>temp)
|
||||
dp[i][j+n1][k+n2][l+n3]=temp;
|
||||
}
|
||||
}
|
||||
int maxn=inf;
|
||||
for(int i=0;i<=c;i++)
|
||||
for(int j=0;j<=c;j++)
|
||||
{
|
||||
if(i+j>m) continue;
|
||||
if(dp[16][i][j][m-i-j] == -1) continue;
|
||||
if(dp[16][i][j][m-i-j]<maxn)
|
||||
maxn=dp[16][i][j][m-i-j];
|
||||
}
|
||||
printf("Case %d: %d\n",T,maxn);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,98 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int L = 1000000+10;
|
||||
int k,n;
|
||||
int ans[L],len;
|
||||
struct node
|
||||
{
|
||||
int l,r,n,lazy;
|
||||
} a[L<<2];
|
||||
void set_up(int i)
|
||||
{
|
||||
a[i].n = max(a[2*i].n,a[2*i+1].n);
|
||||
}
|
||||
void set_down(int i)
|
||||
{
|
||||
if(a[i].lazy)
|
||||
{
|
||||
a[2*i].n += a[i].lazy;
|
||||
a[2*i].lazy+=a[i].lazy;
|
||||
a[2*i+1].n += a[i].lazy;
|
||||
a[2*i+1].lazy+=a[i].lazy;
|
||||
a[i].lazy = 0;
|
||||
}
|
||||
}
|
||||
void init(int l,int r,int i)
|
||||
{
|
||||
a[i].l = l;
|
||||
a[i].r = r;
|
||||
a[i].n = 0;
|
||||
a[i].lazy = 0;
|
||||
if(l!=r)
|
||||
{
|
||||
int mid = (l+r)>>1;
|
||||
init(l,mid,2*i);
|
||||
init(mid+1,r,2*i+1);
|
||||
}
|
||||
}
|
||||
void insert(int l,int r,int i)
|
||||
{
|
||||
if(a[i].l == l && a[i].r == r)
|
||||
{
|
||||
a[i].n++;
|
||||
a[i].lazy++;
|
||||
return;
|
||||
}
|
||||
set_down(i);
|
||||
int mid = (a[i].l+a[i].r)>>1;
|
||||
if(r<=mid)
|
||||
insert(l,r,2*i);
|
||||
else if(l>mid)
|
||||
insert(l,r,2*i+1);
|
||||
else
|
||||
{
|
||||
insert(l,mid,2*i);
|
||||
insert(mid+1,r,2*i+1);
|
||||
}
|
||||
set_up(i);
|
||||
}
|
||||
int query(int l,int r,int i)
|
||||
{
|
||||
if(a[i].l == l && a[i].r == r)
|
||||
return a[i].n;
|
||||
set_down(i);
|
||||
int mid = (a[i].l+a[i].r)>>1;
|
||||
if(r<=mid)
|
||||
return query(l,r,2*i);
|
||||
else if(l>mid)
|
||||
return query(l,r,2*i+1);
|
||||
else
|
||||
return max(query(l,mid,2*i),query(mid+1,r,2*i+1));
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t,cas = 1,i,a,b;
|
||||
for(scanf("%d",&t); t--;)
|
||||
{
|
||||
len = 0;
|
||||
scanf("%d%d",&k,&n);
|
||||
init(1,1000000,1);
|
||||
for(i = 1; i<=n; i++)
|
||||
{
|
||||
scanf("%d%d",&a,&b);
|
||||
b--;
|
||||
if(query(a,b,1)<k)
|
||||
{
|
||||
ans[len++] = i;
|
||||
insert(a,b,1);
|
||||
}
|
||||
}
|
||||
printf("Case %d:\n",cas++);
|
||||
for(i = 0; i<len; i++)
|
||||
printf("%d ",ans[i]);
|
||||
printf("\n\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,59 @@
|
|||
#include <map>
|
||||
#include <stack>
|
||||
#include <queue>
|
||||
#include <math.h>
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#include <fstream>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#define N 4005
|
||||
#define M
|
||||
#define E
|
||||
#define INF 0x3f3f3f3f
|
||||
#define eps 1e-8
|
||||
#define LL long long
|
||||
#define D(a) ((a)*(a))
|
||||
using namespace std;
|
||||
int dp[N],n,a[N],b[N];
|
||||
void re(void)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
}
|
||||
void run(void)
|
||||
{
|
||||
memset(dp,-1,sizeof(dp));
|
||||
dp[2000]=0;
|
||||
int flag=0;
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
int v;
|
||||
scanf("%d",&v);
|
||||
if(v==0)flag++;
|
||||
memset(a,-1,sizeof(a));
|
||||
memset(b,-1,sizeof(b));
|
||||
for(int i=0;i<=4000;i++)
|
||||
if(~dp[i])
|
||||
a[i-v]=max(dp[i-v],dp[i]+v),
|
||||
b[i+v]=max(dp[i+v],dp[i]+v);
|
||||
for(int i=0;i<=4000;i++)
|
||||
dp[i]=max(dp[i],max(a[i],b[i]));
|
||||
}
|
||||
if(dp[2000]==0&&flag<1)printf("-1\n");
|
||||
else printf("%d\n",dp[2000]/2);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int ncase;
|
||||
scanf("%d",&ncase);
|
||||
for(int i=1;i<=ncase;i++)
|
||||
{
|
||||
re();
|
||||
printf("Case %d: ",i);
|
||||
run();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,54 @@
|
|||
#include<stdio.h>
|
||||
#include<stdlib.h>
|
||||
#include<string.h>
|
||||
int alp[52][52];
|
||||
bool mark[26];
|
||||
int num[26];
|
||||
int size;
|
||||
int dir[8][4]={{-1, 0, 1, 1}, {1, 0, -1, 1}, {1, 0, -1, -1}, {-1, 0, 1, -1}, {-1, 1, 1, 0}, {1, 1, 0, -1}, {-1, -1, 1, 0}, {-1, 1, 0, -1}};
|
||||
bool ok(int x, int y, int k, int d)
|
||||
{
|
||||
int i=x, j=y, len, l;
|
||||
i+=dir[k][0]*d;j+=dir[k][1]*d;
|
||||
if(k<4)len=d+1;
|
||||
else len=2*d+1;
|
||||
for(l=0; l<len; l++, i+=dir[k][2], j+=dir[k][3]){
|
||||
if(i<0||i>size||j<0||j>size||alp[i][j]!=alp[x][y])return false;
|
||||
}
|
||||
num[alp[x][y]-'A']++;
|
||||
return true;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t, ca, i, j, k, deep;
|
||||
scanf("%d",&t);
|
||||
for(ca=1; ca<=t; ca++){
|
||||
scanf("%d", &size);
|
||||
getchar();
|
||||
memset(mark, false, sizeof(mark));
|
||||
memset(alp, 0, sizeof(alp));
|
||||
for(i=0; i<size; i++){
|
||||
for(j=0; j<size; j++){
|
||||
scanf("%c", &alp[i][j]);
|
||||
mark[alp[i][j]-'A']=true;
|
||||
}
|
||||
getchar();
|
||||
}
|
||||
memset(num, 0, sizeof(num));
|
||||
for(i=0; i<size; i++){
|
||||
for(j=0; j<size; j++){
|
||||
for(k=0; k<=7; k++){
|
||||
deep=1;
|
||||
while(ok(i, j, k, deep)){
|
||||
deep++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("Case %d:\n", ca);
|
||||
for(i=0; i<26; i++)
|
||||
if(mark[i])
|
||||
printf("%c %d\n", i+'A', num[i]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,70 @@
|
|||
#include<cstdio>
|
||||
#include<cstdlib>
|
||||
#include<cstring>
|
||||
#include<cmath>
|
||||
#include<queue>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
struct segment
|
||||
{
|
||||
int s, e;
|
||||
bool operator <(const segment &t)const
|
||||
{
|
||||
return e>t.e;
|
||||
}
|
||||
}seg[100005];
|
||||
int p[505], n, m;
|
||||
int num[505][505];
|
||||
bool cmp(segment a, segment b)
|
||||
{
|
||||
if(a.s==b.s)return a.e<b.e;
|
||||
return a.s<b.s;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t, ca, i, j, k;
|
||||
scanf("%d", &ca);
|
||||
for(t=1; t<=ca; t++)
|
||||
{
|
||||
scanf("%d%d", &n, &m);
|
||||
for(i=0; i<n; i++)
|
||||
scanf("%d%d", &seg[i].s, &seg[i].e);
|
||||
sort(seg, seg+n, cmp);
|
||||
for(i=0; i<m; i++)
|
||||
scanf("%d", &p[i]);
|
||||
memset(num, 0, sizeof(num));
|
||||
segment ts;
|
||||
k=0;
|
||||
for(i=0; i<m; i++)
|
||||
{
|
||||
priority_queue<segment> q;
|
||||
for(; k<n; k++)
|
||||
{
|
||||
if(seg[k].e<p[i])continue;
|
||||
if(seg[k].s>p[i])break;
|
||||
q.push(seg[k]);
|
||||
}
|
||||
for(j=i; j<m; j++)
|
||||
{
|
||||
if(i!=0)num[i][j]=num[i-1][j];
|
||||
while(!q.empty())
|
||||
{
|
||||
ts=q.top();
|
||||
if(ts.e>=p[j])break;
|
||||
q.pop();
|
||||
}
|
||||
num[i][j]+=q.size();
|
||||
num[j][i]=num[i][j];
|
||||
}
|
||||
}
|
||||
printf("Case %d:\n", t);
|
||||
for(i=0; i<m; i++)
|
||||
{
|
||||
for(j=0; j<m-1; j++)
|
||||
printf("%d ", num[i][j]);
|
||||
printf("%d\n", num[i][j]);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,76 @@
|
|||
#include<iostream>
|
||||
#include<cstring>
|
||||
#include<cstdio>
|
||||
#include<queue>
|
||||
using namespace std;
|
||||
int n,flag,ex,ey;
|
||||
char map[15][15];
|
||||
struct node{
|
||||
int cnt;int s;int x,y;
|
||||
char map[12][12];
|
||||
}s_pos;
|
||||
bool vis[12][12][12][1<<11];
|
||||
bool cheack(int x,int y){
|
||||
return x>=0&&x<n&&y>=0&&y<n;
|
||||
}
|
||||
int dir[4][2]={{1,0},{-1,0},{0,-1},{0,1}};
|
||||
void bfs(){
|
||||
memset(vis,false,sizeof(vis));
|
||||
queue<node > q;
|
||||
q.push(s_pos);
|
||||
vis[s_pos.x][s_pos.y][s_pos.cnt][s_pos.s]=true;
|
||||
while(!q.empty()){
|
||||
node now = q.front(); q.pop();
|
||||
if(now.x==ex&&now.y==ey){
|
||||
flag=1; return ;
|
||||
}
|
||||
for(int i=0;i<4;i++){
|
||||
node next = now; int x=next.x; int y=next.y;
|
||||
x+=dir[i][0], y+=dir[i][1];
|
||||
if(cheack(x,y)){
|
||||
if(map[x][y]=='*') continue;
|
||||
next.x=x; next.y=y;
|
||||
if(next.map[x][y]=='K'){
|
||||
next.map[x][y]='.';
|
||||
next.cnt+=1;
|
||||
}
|
||||
if(next.map[x][y]>='a'&&next.map[x][y]<='z'){
|
||||
if(next.cnt>0){
|
||||
next.s|=(1<<(next.map[x][y]-'a'));
|
||||
next.cnt-=1;
|
||||
next.map[x][y]='.';
|
||||
}
|
||||
else continue;
|
||||
}
|
||||
if(!vis[x][y][next.cnt][next.s]){
|
||||
vis[x][y][next.cnt][next.s]=true;
|
||||
q.push(next);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int main(){
|
||||
int t;int ca=1;scanf("%d",&t);
|
||||
while(t--){
|
||||
scanf("%d",&n);
|
||||
for(int i=0;i<n;i++) scanf("%s",map[i]);
|
||||
s_pos.cnt=s_pos.s=0; char temp='a';
|
||||
for(int i=0;i<n;i++) for(int j=0;j<n;j++){
|
||||
if(map[i][j]=='S') s_pos.x=i,s_pos.y=j;
|
||||
if(map[i][j]=='E') ex=i, ey=j;
|
||||
if(map[i][j]=='L') {
|
||||
s_pos.map[i][j]=temp;
|
||||
temp=temp+1;
|
||||
continue;
|
||||
}
|
||||
s_pos.map[i][j]=map[i][j];
|
||||
}
|
||||
flag=0;
|
||||
bfs();
|
||||
printf("Case %d: ",ca++);
|
||||
if(flag) printf("Yes\n");
|
||||
else printf("No\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,83 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
#include<vector>
|
||||
#include<queue>
|
||||
using namespace std;
|
||||
int n;
|
||||
void print(int num)
|
||||
{
|
||||
for(int i = 1; i <= num ; i++)
|
||||
putchar('\t');
|
||||
}
|
||||
void print(int num, int pos , char A[])
|
||||
{
|
||||
if(pos == n)
|
||||
{
|
||||
print(num);
|
||||
printf("printf(\"");
|
||||
for(int i = 0 ; i < n ; i++)
|
||||
{
|
||||
if(i)putchar('<');
|
||||
printf("%c" , A[i]);
|
||||
}
|
||||
puts("\\n\");");
|
||||
return;
|
||||
}
|
||||
for(int i = pos; i > 0 ; i-- , num++ )
|
||||
{
|
||||
print(num);
|
||||
printf("if (%c<%c)\n",A[i-1],A[i]);
|
||||
char _A[10];
|
||||
for(int j = 0 ; j < n; j++)
|
||||
_A[j] = A[j];
|
||||
print(num+1 , pos+1 ,_A);
|
||||
print(num);
|
||||
puts("else");
|
||||
swap(A[i-1] , A[i]);
|
||||
}
|
||||
print(num,pos+1,A);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d",&n),n)
|
||||
{
|
||||
puts("#include <stdio.h>\n");
|
||||
printf("int ");
|
||||
for(int i = 0 ; i < n ; i++)
|
||||
{
|
||||
if(i)putchar(',');
|
||||
putchar('a'+i);
|
||||
}
|
||||
puts(";\nbool ok;\n\nint main()\n{");
|
||||
printf("\tprintf(\"Please enter %d different integers:\\n\");\n",n);
|
||||
puts("\tdo\n\t{");
|
||||
printf("\t\tscanf(\"");
|
||||
for(int i = 0 ; i< n ;i++)
|
||||
{
|
||||
printf("%%d");
|
||||
}
|
||||
printf("\"");
|
||||
for(int i = 0 ; i< n ;i++)
|
||||
{
|
||||
printf(",&%c",'a'+i);
|
||||
}
|
||||
puts(");");
|
||||
printf("\t\tok=1;\n\t\tif (");
|
||||
for(int i = 0; i < n-1 ;i ++)
|
||||
{
|
||||
for(int j = i+1; j < n; j++)
|
||||
{
|
||||
printf("%c==%c",'a'+i,'a'+j);
|
||||
if(i!=n-2 || j!=n-1)printf(" || ");
|
||||
}
|
||||
}
|
||||
puts(")\n\t\t\tok=0;\n\t}while (ok);");
|
||||
char A[10];
|
||||
for(int i = 0 ; i < n ; i++)
|
||||
A[i] = 'a'+i;
|
||||
print(1,0,A);
|
||||
puts("\treturn 0;\n}\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
#include<iostream>
|
||||
#include<queue>
|
||||
#include<algorithm>
|
||||
int MIN(int a,int b) { if( a<b ) return a; else return b; }
|
||||
int MAX(int a,int b) { if( a>b ) return a; else return b; }
|
||||
#define CLR(NAME,VALUE) memset(NAME,VALUE,sizeof(NAME))
|
||||
using namespace std;
|
||||
const int N=100+10;
|
||||
int c[N][N][N];
|
||||
int GetSum(int x,int y,int z) {
|
||||
int yy,zz,sum=0;
|
||||
for(;x>0;x-=(-x)&x)
|
||||
for(yy=y;yy>0;yy-=(-yy)&yy)
|
||||
for(zz=z;zz>0;zz-=(-zz)&zz)
|
||||
sum=(sum+c[x][yy][zz])&1;
|
||||
return sum;
|
||||
}
|
||||
void Update(int x,int y,int z) {
|
||||
int yy,zz;
|
||||
for(;x<=N;x+=(-x)&x)
|
||||
for(yy=y;yy<=N;yy+=(-yy)&yy)
|
||||
for(zz=z;zz<=N;zz+=(-zz)&zz)
|
||||
c[x][yy][zz]^=1;
|
||||
}
|
||||
int main() {
|
||||
int n,m,q,x,y,z,x1,y1,z1,x2,y2,z2;
|
||||
while( scanf("%d%d",&n,&m)!=EOF ) {
|
||||
CLR(c,0);
|
||||
while( m-- ) {
|
||||
scanf("%d",&q);
|
||||
if( q==1 ) {
|
||||
scanf("%d%d%d%d%d%d",&x1,&y1,&z1,&x2,&y2,&z2);
|
||||
Update(x1,y1,z1);
|
||||
Update(x1,y1,z2+1);
|
||||
Update(x1,y2+1,z1);
|
||||
Update(x1,y2+1,z2+1);
|
||||
Update(x2+1,y1,z1);
|
||||
Update(x2+1,y1,z2+1);
|
||||
Update(x2+1,y2+1,z1);
|
||||
Update(x2+1,y2+1,z2+1);
|
||||
}
|
||||
else {
|
||||
scanf("%d%d%d",&x,&y,&z);
|
||||
printf("%d\n",GetSum(x,y,z));
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,140 @@
|
|||
#include<stdio.h>
|
||||
#include<math.h>
|
||||
#include<iostream>
|
||||
#define eps 1e-7
|
||||
using namespace std;
|
||||
int n,k,vis[55],tmax,dp[55],ji;
|
||||
int locat[55][2],map[55][55];
|
||||
double dis[55][55],distan[2000];
|
||||
int cmp(const void *a,const void*b)
|
||||
{
|
||||
return *(double *)a>*(double *)b?1:-1;
|
||||
}
|
||||
void build(int mid)
|
||||
{
|
||||
int i,f;
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
for(f=1;f<=n;f++)
|
||||
{
|
||||
if(dis[i][f] >= distan[mid]-eps)
|
||||
{
|
||||
map[i][f]=1;
|
||||
}
|
||||
else
|
||||
{
|
||||
map[i][f]=0;
|
||||
}
|
||||
}
|
||||
map[i][i]=0;
|
||||
}
|
||||
}
|
||||
void dfs(int id,int cnt)
|
||||
{
|
||||
int tvis[55],i,f,able=0;
|
||||
for(i=id+1;i<=n;i++)
|
||||
{
|
||||
if(1 == vis[i])
|
||||
{
|
||||
able++;
|
||||
}
|
||||
}
|
||||
if(0 == able)
|
||||
{
|
||||
tmax=max(tmax,cnt);
|
||||
}
|
||||
if(cnt + able <= tmax)
|
||||
{
|
||||
return ;
|
||||
}
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
tvis[i]=vis[i];
|
||||
}
|
||||
for(i=id+1;i<=n;i++)
|
||||
{
|
||||
if(0 == tvis[i])
|
||||
{
|
||||
continue;
|
||||
}
|
||||
if(cnt +dp[i] <= tmax)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
for(f=id+1;f<=n;f++)
|
||||
{
|
||||
vis[f]=tvis[f]&map[i][f];
|
||||
}
|
||||
dfs(i,cnt+1);
|
||||
}
|
||||
}
|
||||
int max_clique()
|
||||
{
|
||||
int i,f;
|
||||
tmax=1;
|
||||
dp[n]=1;
|
||||
for(i=n-1;i>=1;i--)
|
||||
{
|
||||
for(f=1;f<=n;f++)
|
||||
{
|
||||
vis[f]=map[i][f];
|
||||
}
|
||||
dfs(i,1);
|
||||
dp[i]=tmax;
|
||||
if(n == tmax)
|
||||
{
|
||||
return tmax;
|
||||
}
|
||||
}
|
||||
return tmax;
|
||||
}
|
||||
double bs()
|
||||
{
|
||||
int l=0,r=ji,mid;
|
||||
while(l != r-1)
|
||||
{
|
||||
mid=(l+r)>>1;
|
||||
build(mid);
|
||||
if(k <= max_clique())
|
||||
{
|
||||
l=mid;
|
||||
}
|
||||
else
|
||||
{
|
||||
r=mid;
|
||||
}
|
||||
}
|
||||
return distan[l];
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,f,g,sum;
|
||||
while(scanf("%d%d",&n,&k)!=EOF)
|
||||
{
|
||||
ji=0;
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
scanf("%d%d",&locat[i][0],&locat[i][1]);
|
||||
}
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
for(f=1;f<=n;f++)
|
||||
{
|
||||
sum=0;
|
||||
for(g=0;g<2;g++)
|
||||
{
|
||||
sum+=(locat[i][g]-locat[f][g])*((locat[i][g]-locat[f][g]));
|
||||
}
|
||||
dis[i][f]=sqrt((double)sum);
|
||||
if(i > f)
|
||||
{
|
||||
distan[ji]=dis[i][f];
|
||||
ji++;
|
||||
}
|
||||
}
|
||||
}
|
||||
qsort(distan,ji,sizeof(distan[0]),cmp);
|
||||
printf("%.2lf\n",bs());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,64 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
const int VM=1010;
|
||||
const int INF=1000010;
|
||||
struct Edge{
|
||||
int to,nxt;
|
||||
int cap;
|
||||
}edge[VM<<1];
|
||||
int n,m,cnt,head[VM];
|
||||
int dp[VM],vis[VM];
|
||||
void addedge(int cu,int cv,int cw){
|
||||
edge[cnt].to=cv;
|
||||
edge[cnt].cap=cw;
|
||||
edge[cnt].nxt=head[cu];
|
||||
head[cu]=cnt++;
|
||||
}
|
||||
void DFS(int u,int pre,int lim){
|
||||
int flag=0;
|
||||
dp[u]=0;
|
||||
for(int i=head[u];i!=-1;i=edge[i].nxt){
|
||||
int v=edge[i].to;
|
||||
if(v!=pre){
|
||||
flag=1;
|
||||
DFS(v,u,lim);
|
||||
if(edge[i].cap<=lim)
|
||||
dp[u]+=min(dp[v],edge[i].cap);
|
||||
else
|
||||
dp[u]+=dp[v];
|
||||
}
|
||||
}
|
||||
if(!flag)
|
||||
dp[u]=INF;
|
||||
}
|
||||
int main(){
|
||||
while(~scanf("%d%d",&n,&m)){
|
||||
if(n==0 && m==0)
|
||||
break;
|
||||
cnt=0;
|
||||
memset(head,-1,sizeof(head));
|
||||
int MAX=0;
|
||||
int u,v,w;
|
||||
for(int i=1;i<n;i++){
|
||||
scanf("%d%d%d",&u,&v,&w);
|
||||
addedge(u,v,w);
|
||||
addedge(v,u,w);
|
||||
if(w>MAX)
|
||||
MAX=w;
|
||||
}
|
||||
int l=1,r=MAX,ans=-1;
|
||||
while(l<=r){
|
||||
int mid=(l+r)>>1;
|
||||
DFS(1,-1,mid);
|
||||
if(dp[1]<=m){
|
||||
ans=mid;
|
||||
r=mid-1;
|
||||
}else
|
||||
l=mid+1;
|
||||
}
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,80 @@
|
|||
#include<stdio.h>
|
||||
#include<stdlib.h>
|
||||
#include<string.h>
|
||||
struct man
|
||||
{
|
||||
int team;
|
||||
char name[15];
|
||||
int po;
|
||||
int lt;
|
||||
int kiin;
|
||||
}mn[2005];
|
||||
int main()
|
||||
{
|
||||
int i, j, n, m, k, ct, an, bn;
|
||||
bool fir;
|
||||
char ch[3], killer[15], killed[15];
|
||||
while(scanf("%d%d%d", &n, &m, &k)!=EOF)
|
||||
{
|
||||
fir=false;
|
||||
for(i=0; i<n+m; i++)
|
||||
{
|
||||
if(i<n)
|
||||
mn[i].team=1;
|
||||
else
|
||||
mn[i].team=2;
|
||||
scanf("%s", mn[i].name);
|
||||
mn[i].po=603;mn[i].kiin=0;mn[i].lt=0;
|
||||
}
|
||||
getchar();//care!!!!!!!!!!!!!
|
||||
for(i=0; i<k; i++)
|
||||
{
|
||||
scanf("%s", ch);
|
||||
if(ch[0]=='K')
|
||||
{
|
||||
scanf("%s%s%d", killer, killed, &ct);
|
||||
getchar();
|
||||
an=-1; bn=-1;
|
||||
for(j=0;(!(an>=0&&bn>=0))&&(j<n+m); j++){
|
||||
if(strcmp(mn[j].name, killer)==0)
|
||||
an=j;
|
||||
else if(strcmp(mn[j].name, killed)==0)
|
||||
bn=j;
|
||||
}
|
||||
if(mn[an].team!=mn[bn].team)
|
||||
{
|
||||
mn[an].kiin++;
|
||||
if(fir==false)
|
||||
{mn[an].po+=400;fir=true;}
|
||||
else if(mn[an].kiin>=10)
|
||||
mn[an].po+=600;
|
||||
else if(mn[an].kiin<=1)
|
||||
mn[an].po+=200;
|
||||
else
|
||||
mn[an].po+=(200+50*(mn[an].kiin-2));
|
||||
}
|
||||
mn[bn].po-=300;
|
||||
if(mn[bn].po<0)
|
||||
{
|
||||
mn[bn].po=0;
|
||||
mn[bn].lt=ct;
|
||||
}
|
||||
mn[bn].kiin=0;
|
||||
}
|
||||
else if(ch[0]=='Q')
|
||||
{
|
||||
scanf("%s%d", killer, &ct);
|
||||
getchar();
|
||||
for(j=0; j<n+m; j++)
|
||||
if(strcmp(mn[j].name, killer)==0)
|
||||
{
|
||||
an=j;
|
||||
break;
|
||||
}
|
||||
int re=mn[an].po+ct-mn[an].lt;
|
||||
printf("%d\n", re);
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,78 @@
|
|||
#include <iostream>
|
||||
#include <cmath>
|
||||
#include <string.h>
|
||||
using namespace std;
|
||||
const int MAX = 1000000 + 1;
|
||||
int prime[MAX];
|
||||
bool isPrime[2 * MAX];
|
||||
int getPrime(int*prime, bool*isPrime, int n, int m)
|
||||
{
|
||||
int p,i,j;
|
||||
memset(isPrime, 1, m);
|
||||
p=isPrime[0]=isPrime[1]=0;
|
||||
for(i=2;i<=n;i++)
|
||||
if(isPrime[i])
|
||||
for(prime[p++]=i,j=2*i;j<=m;j+=i)
|
||||
isPrime[j] = false;
|
||||
return p;
|
||||
}
|
||||
int resolve(int x, int *arr)
|
||||
{
|
||||
int len = 0;
|
||||
for(int i = 0; x != 1; i ++)
|
||||
{
|
||||
if(isPrime[x])
|
||||
{
|
||||
arr[len ++] = x;
|
||||
break;
|
||||
}
|
||||
while(x % prime[i] == 0)
|
||||
{
|
||||
arr[len ++] = prime[i];
|
||||
x /= prime[i];
|
||||
}
|
||||
}
|
||||
return len;
|
||||
}
|
||||
int mod_pow(__int64 a, __int64 k, __int64 m)
|
||||
{
|
||||
static __int64 r;
|
||||
for(r=1; k; k>>=1, a=a*a%m)
|
||||
if(k&1) r = r*a%m;
|
||||
return (int)r;
|
||||
}
|
||||
int oula_judge(int a, int n)
|
||||
{
|
||||
if(a % n == 0)
|
||||
return 0;
|
||||
int t = (n - 1) / 2;
|
||||
int temp = mod_pow(a, t, n);
|
||||
if(temp == 1)
|
||||
return 1;
|
||||
else
|
||||
return -1;
|
||||
}
|
||||
int main(void)
|
||||
{
|
||||
getPrime(prime, isPrime, 1000000, 2 * 1000000);
|
||||
int a, n;
|
||||
while(scanf("%d %d", &a, &n) == 2)
|
||||
{
|
||||
if(isPrime[n] == 1)
|
||||
{
|
||||
cout << oula_judge(a, n) << endl;
|
||||
}
|
||||
else
|
||||
{
|
||||
int ans = 1;
|
||||
int factor[100000];
|
||||
int len = resolve(n, factor);
|
||||
for(int i = 0; i < len; i++)
|
||||
{
|
||||
ans *= oula_judge(a, factor[i]);
|
||||
}
|
||||
cout << ans << endl;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
#include<iostream>
|
||||
#include<cstdlib>
|
||||
#include<stdio.h>
|
||||
#include<vector>
|
||||
using namespace std;
|
||||
vector<int>v[110];
|
||||
int dfs(int x,int pre)
|
||||
{
|
||||
int ans=0;
|
||||
for(int i=0;i<v[x].size();i++)
|
||||
{
|
||||
if(v[x][i]!=pre)
|
||||
ans^=(1+dfs(v[x][i],x));
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,m,a,b;
|
||||
while(scanf("%d",&n)!=EOF)
|
||||
{
|
||||
int ans=0,cnt=0;
|
||||
while(n--)
|
||||
{
|
||||
scanf("%d",&m);
|
||||
for(int i=1;i<=m;i++)
|
||||
v[i].clear();
|
||||
for(int i=1;i<m;i++)
|
||||
{
|
||||
scanf("%d%d",&a,&b);
|
||||
v[a].push_back(b);
|
||||
v[b].push_back(a);
|
||||
}
|
||||
int s=dfs(1,-1);
|
||||
if(s>1) cnt++;
|
||||
ans^=s;
|
||||
}
|
||||
if(cnt>=1)
|
||||
{
|
||||
if(ans) puts("PP");
|
||||
else puts("QQ");
|
||||
}
|
||||
else
|
||||
{
|
||||
if(ans) puts("QQ");
|
||||
else puts("PP");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,61 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <cstdlib>
|
||||
#include <vector>
|
||||
#include <map>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int maxn=1e2+10;
|
||||
const int maxm=2e4+10;
|
||||
const int INF=1e8;
|
||||
int c[maxn],v[maxn],f[maxm],g[maxm];
|
||||
int main()
|
||||
{
|
||||
int n,m,tt=0;
|
||||
while(scanf("%d%d",&n,&m)!=EOF)
|
||||
{
|
||||
if(n==0&&m==0)break;
|
||||
int i,j,k;
|
||||
for(i=0;i<n;i++)
|
||||
scanf("%d",&v[i]);
|
||||
for(i=0;i<n;i++)
|
||||
scanf("%d",&c[i]);
|
||||
for(i=1;i<=20000;i++)
|
||||
{
|
||||
g[i]=f[i]=INF;
|
||||
}
|
||||
f[0]=g[0]=0;
|
||||
//瀹ㄨ
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
for(j=v[i];j<=20000;j++)
|
||||
g[j]=min(g[j],g[j-v[i]]+1);
|
||||
}
|
||||
//澶
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
if(v[i]*c[i]>=20000)
|
||||
{
|
||||
for(j=v[i];j<=20000;j++)
|
||||
f[j]=min(f[j],f[j-v[i]]+1);
|
||||
continue;
|
||||
}
|
||||
for(k=1;k<c[i];k=k*2)
|
||||
{
|
||||
for(j=20000;j>=v[i]*k;j--)
|
||||
f[j]=min(f[j],f[j-v[i]*k]+k);
|
||||
c[i]-=k;
|
||||
}
|
||||
for(j=20000;j>=c[i]*v[i];j--)
|
||||
f[j]=min(f[j],f[j-v[i]*c[i]]+c[i]);
|
||||
}
|
||||
int ans=INF;
|
||||
for(i=m;i<=20000;i++)
|
||||
ans=min(ans,f[i]+g[i-m]);
|
||||
if(ans==INF)ans=-1;
|
||||
printf("Case %d: %d\n",++tt,ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,95 @@
|
|||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <string.h>
|
||||
#define MAXN 1010
|
||||
#define MAXM 20010
|
||||
#define INF 0x7fffffff
|
||||
using namespace std;
|
||||
struct edge
|
||||
{
|
||||
int to,w,next;
|
||||
}E[MAXM];
|
||||
int head[MAXN],ecnt;
|
||||
int Stack[MAXN],dis[MAXN],cnt[MAXN];
|
||||
bool used[MAXN];
|
||||
int N,X,Y,top;
|
||||
void Insert(int from,int to,int w)
|
||||
{
|
||||
E[ecnt].to=to;
|
||||
E[ecnt].w=w;
|
||||
E[ecnt].next=head[from];
|
||||
head[from]=ecnt++;
|
||||
}
|
||||
bool Relax(int from,int to,int w)
|
||||
{
|
||||
if(dis[to]>dis[from]+w)
|
||||
{
|
||||
dis[to]=dis[from]+w;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
void Init()
|
||||
{
|
||||
int i,u,v,w;
|
||||
memset(head,-1,sizeof(head));ecnt=0;
|
||||
for(i=1;i<=X;i++)
|
||||
{
|
||||
scanf("%d%d%d",&u,&v,&w);
|
||||
Insert(u,v,w);
|
||||
}
|
||||
for(i=1;i<=Y;i++)
|
||||
{
|
||||
scanf("%d%d%d",&u,&v,&w);
|
||||
Insert(v,u,-w);
|
||||
}
|
||||
for(i=1;i<N;i++)
|
||||
Insert(i+1,i,0);
|
||||
}
|
||||
int SPFA(int s)
|
||||
{
|
||||
int i,u,v;
|
||||
for(i=0;i<=N;i++)
|
||||
{
|
||||
cnt[i]=0;
|
||||
used[i]=false;
|
||||
dis[i]=INF;
|
||||
}
|
||||
top=0;
|
||||
Stack[top++]=s;
|
||||
dis[s]=0;
|
||||
used[s]=true;
|
||||
while(top)
|
||||
{
|
||||
u=Stack[--top];
|
||||
used[u]=false;
|
||||
cnt[u]++;
|
||||
if(cnt[u]>N)
|
||||
return -1;
|
||||
for(i=head[u];i!=-1;i=E[i].next)
|
||||
{
|
||||
v=E[i].to;
|
||||
if(Relax(u,v,E[i].w)&&!used[v])
|
||||
{
|
||||
Stack[top++]=v;
|
||||
used[v]=true;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(dis[N]==INF)
|
||||
return -2;
|
||||
return dis[N];
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d%d%d",&N,&X,&Y);
|
||||
Init();
|
||||
int ans=SPFA(1);
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
int head[100050];
|
||||
int N,G;
|
||||
int c[100050],v[100050],dp[505][10005];
|
||||
struct NODE
|
||||
{
|
||||
int to,next;
|
||||
}edge[300000];
|
||||
void dfs(int x,int V)
|
||||
{
|
||||
int i,j,k,to;
|
||||
for(i=head[x];i!=-1;i=edge[i].next)
|
||||
{
|
||||
to=edge[i].to;
|
||||
if(head[to] == -1)
|
||||
{
|
||||
for(j=V;j>=c[to];j--)
|
||||
{
|
||||
dp[x][j]=max(dp[x][j],dp[x][j-c[to]]+v[to]);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if(V >= c[to])
|
||||
{
|
||||
for(j=0;j<=V-c[to];j++) dp[to][j]=dp[x][j];
|
||||
dfs(to,V-c[to]);
|
||||
for(j=V;j>=c[to];j--)
|
||||
{
|
||||
dp[x][j]=max(dp[x][j],dp[to][j-c[to]]+v[to]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(~scanf("%d %d",&N,&G))
|
||||
{
|
||||
int i,j,k;
|
||||
memset(head,-1,sizeof(head));
|
||||
memset(dp,0,sizeof(dp));
|
||||
for(i=1;i<=N;i++)
|
||||
{
|
||||
scanf("%d %d %d",&c[i],&v[i],&j);
|
||||
if(i == j) edge[i].to=i,edge[i].next=head[0],head[0]=i;
|
||||
else edge[i].to=i,edge[i].next=head[j],head[j]=i;
|
||||
}
|
||||
c[0]=v[0]=0;
|
||||
dfs(0,G);
|
||||
int ans=0;
|
||||
printf("%d\n",dp[0][G]);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,77 @@
|
|||
# include<stdio.h>
|
||||
# include<string.h>
|
||||
# define N 20005
|
||||
# define M 50005
|
||||
# include<stack>
|
||||
using namespace std;
|
||||
struct node{
|
||||
int from,to,next;
|
||||
}edge[M];
|
||||
int tol,head[N],dfn[N],low[N],flag,count,cnt,n;
|
||||
bool visit[N],vis[N];
|
||||
stack<int>S;
|
||||
void add(int a,int b)
|
||||
{
|
||||
edge[tol].from=a;edge[tol].to=b;edge[tol].next=head[a];head[a]=tol++;
|
||||
}
|
||||
int min(int a,int b)
|
||||
{
|
||||
return a<b?a:b;
|
||||
}
|
||||
void tarjan(int u)
|
||||
{
|
||||
int j,v;
|
||||
dfn[u]=low[u]=cnt++;
|
||||
visit[u]=vis[u]=1;
|
||||
S.push(u);
|
||||
for(j=head[u];j!=-1;j=edge[j].next)
|
||||
{
|
||||
v=edge[j].to;
|
||||
if(!visit[v])
|
||||
{
|
||||
tarjan(v);
|
||||
low[u]=min(low[u],low[v]);
|
||||
}
|
||||
else if(vis[v])
|
||||
{
|
||||
low[u]=min(low[u],dfn[v]);
|
||||
if(dfn[v]!=low[v]) flag=1;
|
||||
}
|
||||
if(flag) return;
|
||||
}
|
||||
if(dfn[u]==low[u])
|
||||
{
|
||||
count++;
|
||||
do{
|
||||
v=S.top();
|
||||
S.pop();
|
||||
vis[v]=0;
|
||||
}while(v!=u);
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,ncase,a,b;
|
||||
scanf("%d",&ncase);
|
||||
while(ncase--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
tol=0;
|
||||
memset(head,-1,sizeof(head));
|
||||
while(scanf("%d%d",&a,&b)!=EOF)
|
||||
{
|
||||
if(!a && !b) break;
|
||||
add(a,b);
|
||||
}
|
||||
memset(visit,0,sizeof(visit));
|
||||
memset(vis,0,sizeof(vis));
|
||||
flag=0;
|
||||
count=0;
|
||||
cnt=0;
|
||||
for(i=0;i<n;i++)
|
||||
if(!visit[i]) tarjan(i);
|
||||
if(flag||count!=1) printf("NO\n");
|
||||
else printf("YES\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<cmath>
|
||||
#include<algorithm>
|
||||
#define N 10005
|
||||
#define LL long long
|
||||
#define inf 1<<29
|
||||
#define eps 1e-7
|
||||
using namespace std;
|
||||
int main(){
|
||||
int n;
|
||||
while(scanf("%d",&n)!=EOF){
|
||||
int ans=0;
|
||||
while(n--){
|
||||
int p,q,len=2,f[100];
|
||||
scanf("%d%d",&p,&q);
|
||||
if(p<q) swap(p,q);
|
||||
f[1]=p;f[2]=q;
|
||||
while(f[len]){
|
||||
f[len+1]=f[len-1]%f[len];
|
||||
len++;
|
||||
}
|
||||
int k=len-2,j=-1;
|
||||
for(int i=1;i<len-1;i++){
|
||||
if(f[i]/f[i+1]>1){
|
||||
if(j>0&&i%2!=j%2)
|
||||
k++;
|
||||
j=i;
|
||||
}
|
||||
}
|
||||
ans=max(ans,k);
|
||||
}
|
||||
if(ans&1) puts("MM");
|
||||
else puts("GG");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,125 @@
|
|||
#include <cstdio>
|
||||
#include <ctype.h>
|
||||
#include <cmath>
|
||||
#include <stdlib.h>
|
||||
char rin[10100],rout[10100];
|
||||
struct sta{
|
||||
double x;
|
||||
bool digit;
|
||||
char ch;
|
||||
} stack[10100];
|
||||
double tst[10100];
|
||||
int top,ttop,rtop;
|
||||
int priority(char ch)
|
||||
{
|
||||
switch (ch)
|
||||
{
|
||||
case '+' :
|
||||
case '-' : return 1;break;
|
||||
case '*' :
|
||||
case '/' : return 2;break;
|
||||
case '^' : return 3;break;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i;
|
||||
bool mark;
|
||||
while (scanf("%s",rin) != EOF)
|
||||
{
|
||||
mark = true;
|
||||
top = 0; i = 0; rtop = 0;
|
||||
while (rin[i])
|
||||
{
|
||||
if (mark)
|
||||
{
|
||||
mark = false;
|
||||
while (rin[i] == '(')
|
||||
{
|
||||
i ++;
|
||||
rout[++rtop] = '(';
|
||||
}
|
||||
if (rin[i] == '-' || rin[i] == '+')
|
||||
{
|
||||
stack[++top].x = 0;
|
||||
stack[top].digit = true;
|
||||
}
|
||||
else {
|
||||
sscanf(&rin[i],"%lf",&stack[++top].x);
|
||||
stack[top].digit = true;
|
||||
while (!isdigit(rin[i]))
|
||||
i++;
|
||||
while (isdigit(rin[i]) || rin[i] == '.')
|
||||
i++;
|
||||
}
|
||||
}
|
||||
else {
|
||||
mark = true;
|
||||
if (rin[i] == ')')
|
||||
{
|
||||
while (rout[rtop] != '(')
|
||||
{
|
||||
stack[++top].ch = rout[rtop--];
|
||||
stack[top].digit = false;
|
||||
}
|
||||
rtop--;
|
||||
mark = false;
|
||||
}
|
||||
else {
|
||||
if (!rtop || rout[rtop] == '(')
|
||||
rout[++rtop] = rin[i];
|
||||
else {
|
||||
while ( rtop&& priority(rin[i]) < priority(rout[rtop]))
|
||||
{
|
||||
stack[++top].ch = rout[rtop--];
|
||||
stack[top].digit = false;
|
||||
}
|
||||
if (rtop && priority(rin[i]) == priority(rout[rtop]))
|
||||
{
|
||||
stack[++top].ch = rout[rtop];
|
||||
stack[top].digit = false;
|
||||
rout[rtop] = rin[i];
|
||||
}
|
||||
else rout[++rtop] = rin[i];
|
||||
}
|
||||
}
|
||||
i ++;
|
||||
}
|
||||
}
|
||||
while (rtop)
|
||||
{
|
||||
stack[++top].ch = rout[rtop--];
|
||||
stack[top].digit = false;
|
||||
}
|
||||
ttop = 0; i = 1;
|
||||
bool flag = true;
|
||||
while (i <= top && flag)
|
||||
{
|
||||
if (stack[i].digit)
|
||||
tst[++ttop] = stack[i].x;
|
||||
else {
|
||||
double b = tst[ttop--], a = tst[ttop];
|
||||
switch (stack[i].ch)
|
||||
{
|
||||
case '+': tst[ttop] = a + b;
|
||||
break;
|
||||
case '-': tst[ttop] = a - b;
|
||||
break;
|
||||
case '*': tst[ttop] = a * b;
|
||||
break;
|
||||
case '/': if (fabs(b) < 0.00000001)
|
||||
flag = false;
|
||||
else tst[ttop] = a / b;
|
||||
break;
|
||||
case '^': tst[ttop] = pow(a,b);
|
||||
break;
|
||||
}
|
||||
}
|
||||
i++;
|
||||
}
|
||||
if (flag)
|
||||
printf("%.8lf\n",tst[ttop]);
|
||||
else printf("The teacher is so lazy!\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,160 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<string.h>
|
||||
#include<algorithm>
|
||||
#include<vector>
|
||||
#include<queue>
|
||||
using namespace std;
|
||||
#define MAXN 4444
|
||||
#define inf 1<<30
|
||||
struct Node{
|
||||
int v,w;
|
||||
Node(int vv,int ww):v(vv),w(ww){};
|
||||
};
|
||||
int n;
|
||||
bool mark[MAXN];
|
||||
int dist[MAXN];
|
||||
vector<vector<Node> >G;
|
||||
void spfa()
|
||||
{
|
||||
memset(mark,false,sizeof(mark));
|
||||
fill(dist,dist+n+2,inf);
|
||||
dist[1]=0;
|
||||
queue<int>que;
|
||||
que.push(1);
|
||||
while(!que.empty()){
|
||||
int u=que.front();
|
||||
que.pop();
|
||||
mark[u]=false;
|
||||
for(int i=0;i<G[u].size();i++){
|
||||
int v=G[u][i].v;
|
||||
int w=G[u][i].w;
|
||||
if(dist[u]+w<dist[v]){
|
||||
dist[v]=dist[u]+w;
|
||||
if(!mark[v]){
|
||||
mark[v]=true;
|
||||
que.push(v);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
struct Edge{
|
||||
int v,cap,next;
|
||||
}edge[MAXN*MAXN];
|
||||
int NE,NV;
|
||||
int head[MAXN];
|
||||
void Insert(int u,int v,int cap)
|
||||
{
|
||||
edge[NE].v=v;
|
||||
edge[NE].cap=cap;
|
||||
edge[NE].next=head[u];
|
||||
head[u]=NE++;
|
||||
edge[NE].v=u;
|
||||
edge[NE].cap=0;
|
||||
edge[NE].next=head[v];
|
||||
head[v]=NE++;
|
||||
}
|
||||
void Build()
|
||||
{
|
||||
NE=0;
|
||||
NV=n;
|
||||
memset(head,-1,sizeof(head));
|
||||
for(int u=1;u<=n;u++){
|
||||
for(int i=0;i<G[u].size();i++){
|
||||
int v=G[u][i].v,w=G[u][i].w;
|
||||
if(dist[u]+w==dist[v]){
|
||||
Insert(u,v,1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int level[MAXN],gap[MAXN];
|
||||
void bfs(int vt)
|
||||
{
|
||||
memset(level,-1,sizeof(level));
|
||||
memset(gap,0,sizeof(gap));
|
||||
queue<int>que;
|
||||
que.push(vt);
|
||||
level[vt]=0;
|
||||
gap[level[vt]]++;
|
||||
while(!que.empty()){
|
||||
int u=que.front();
|
||||
que.pop();
|
||||
for(int i=head[u];i!=-1;i=edge[i].next){
|
||||
int v=edge[i].v;
|
||||
if(level[v]!=-1)continue;
|
||||
level[v]=level[u]+1;
|
||||
gap[level[v]]++;
|
||||
que.push(v);
|
||||
}
|
||||
}
|
||||
}
|
||||
int pre[MAXN],cur[MAXN];
|
||||
int SAP(int vs,int vt)
|
||||
{
|
||||
bfs(vt);
|
||||
memset(pre,-1,sizeof(pre));
|
||||
memcpy(cur,head,sizeof(head));
|
||||
int u=pre[vs]=vs,aug=inf,maxflow=0;
|
||||
gap[0]=NV;
|
||||
while(level[vs]<NV){
|
||||
bool flag=false;
|
||||
for(int &i=cur[u];i!=-1;i=edge[i].next){
|
||||
int v=edge[i].v;
|
||||
if(edge[i].cap>0&&level[u]==level[v]+1){
|
||||
flag=true;
|
||||
aug=min(aug,edge[i].cap);
|
||||
pre[v]=u;
|
||||
u=v;
|
||||
if(v==vt){
|
||||
maxflow+=aug;
|
||||
for(u=pre[v];v!=vs;v=u,u=pre[u]){
|
||||
edge[cur[u]].cap-=aug;
|
||||
edge[cur[u]^1].cap+=aug;
|
||||
}
|
||||
aug=inf;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(flag)continue;
|
||||
int minlevel=NV;
|
||||
for(int i=head[u];i!=-1;i=edge[i].next){
|
||||
int v=edge[i].v;
|
||||
if(edge[i].cap>0&&level[v]<minlevel){
|
||||
minlevel=level[v];
|
||||
cur[u]=i;
|
||||
}
|
||||
}
|
||||
if(--gap[level[u]]==0)break;
|
||||
level[u]=minlevel+1;
|
||||
gap[level[u]]++;
|
||||
u=pre[u];
|
||||
}
|
||||
return maxflow;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int _case,u,v,w;
|
||||
scanf("%d",&_case);
|
||||
while(_case--){
|
||||
scanf("%d",&n);
|
||||
G.clear();
|
||||
G.resize(n+2);
|
||||
while(true){
|
||||
scanf("%d%d%d",&u,&v,&w);
|
||||
if(u==0&&v==0&&w==0)break;
|
||||
G[u].push_back(Node(v,w));
|
||||
G[v].push_back(Node(u,w));
|
||||
}
|
||||
spfa();
|
||||
if(dist[n]==inf||n==1){
|
||||
puts("0");
|
||||
continue;
|
||||
}
|
||||
Build();
|
||||
printf("%d\n",SAP(1,n));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
Loading…
Reference in New Issue