Kiritow/OJ-Problems-Source
1
0
Fork 0
mirror of https://github.com/Kiritow/OJ-Problems-Source.git synced 2024-03-22 13:11:29 +08:00
Code Issues Projects Releases Wiki Activity

Powered By HC TECH : AutoACer Engine

Browse Source 
2700-2799
This commit is contained in:
KiritoTRw 2016-08-24 18:23:25 +08:00 committed by GitHub
parent 7a2a9109f5
commit 1b4d6396e4
64 changed files with 4623 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
HDOJ/2700_autoAC.cpp Normal file
View File

@ -0,0 +1,37 @@
#include<stdio.h>
#include<string.h>
int main()
{
char a[35];
int i,c,l;
while(gets(a)&&a[0]!='#')
{
c=0;
l=strlen(a);
for(i=0;i<=l-2;i++)
if(a[i]=='1')
c++;
if(a[l-1]=='e')
{
if(c%2!=0)
a[l-1]='1';
else
a[l-1]='0';
}
else
{
if(c%2!=0)
a[l-1]='0';
else
a[l-1]='1';
}
for(i=0;i<l;i++)
{
if(i==l-1)
printf("%c\n",a[i]);
else
printf("%c",a[i]);
}
}
return 0;
}

34
HDOJ/2701_autoAC.cpp Normal file
View File

@ -0,0 +1,34 @@
# include <stdio.h>
# include <math.h>
int r, x, y ;
double dist(double ax, double ay, double bx, double by)
{
return sqrt((ax-bx)*(ax-bx) + (ay-by)*(ay-by)) ;
}
void work(int cas)
{
double sx = x, sy = y, ex, ey, t ;
int flag = 0 ;
while (1)
{
scanf ("%lf%lf", &ex, &ey) ;
if (ex < 0 && ey < 0) break ;
if (flag) continue ;
if (dist(sx, sy, ex, ey) <= r+1.0)
{
printf ("Firefly %d caught at (%.0lf,%.0lf)\n", cas, ex, ey) ;
flag = 1 ;
}
t = r*1.0 / dist(sx, sy, ex, ey) ;
sx = sx + (ex-sx)*t ;
sy = sy + (ey-sy)*t ;
}
if (!flag) printf ("Firefly %d not caught\n", cas) ;
}
int main ()
{
int nCase = 1 ;
while (scanf ("%d%d%d", &r, &x, &y) && (r||x||y))
work(nCase++) ;
return 0 ;
}

171
HDOJ/2702_autoAC.cpp Normal file
View File

@ -0,0 +1,171 @@
#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <iostream>
#include <stack>
using namespace std;
int R,C;
char Map[10][10];
int Move2[6][2] = {{-1,-1},{-1,0},{0,-1},{0,1},{1,-1},{1,0}};
int Move1[6][2] = {{-1,0},{-1,1},{0,-1},{0,1},{1,0},{1,1}};
char Path[20];
bool bVisited[10][10];
int ileft,iright;
int cnum,pos;
inline bool InBoundary(int x,int y)
{
if(x >= 0 && x<R && y>=0 && y<C+x%2)
return true;
return false;
}
bool Evaluate(int start,int n,int &value)
{
stack<int> s1;
stack<char> s2;
int i = start;
int t = 0;
t = Path[i]-'0'; i++;
if(isdigit(Path[i]))
{
if(t == 0) return false;
}
while(isdigit(Path[i]))
{
t*=10; t+=Path[i]-'0';
if(t >= 100)
return false;
i++;
}
s1.push(t);
while(1)
{
if(i > n-1)
{
if(!isdigit(Path[n-1])) return false;
break;
}
if(!isdigit(Path[i]))
{
if(!s2.empty()) return false;
else s2.push(Path[i]);
i++;
}
else
{
t = Path[i]-'0'; i++;
if(isdigit(Path[i]))
{
if(t == 0)
return false;
}
while(isdigit(Path[i]))
{
t*=10; t+=Path[i]-'0';
if(t >= 100)
return false;
i++;
}
char op = s2.top();s2.pop();
int re = s1.top();s1.pop();
switch(op)
{
case '+':s1.push(re+t); break;
case '-':s1.push(re-t);break;
case '*':s1.push(re*t);break;
case '/':
if(t == 0 || re%t!=0)
return false;
s1.push(re/t);
break;
}
}
}
value = s1.top();
return true;
}
bool DFS(int i,int j,int index)
{
if(index == cnum)
{
Path[index] = 0;
if(Evaluate(pos,index,iright) && iright == ileft)
return true;
else return false;
}
if(Map[i][j] == '=')
{
if(!Evaluate(0,index-1,ileft))
return false;
pos = index;
}
if(i%2==1)
{
for(int k = 0; k<6; k++)
{
int x = Move2[k][0]+i; int y = Move2[k][1]+j;
if(InBoundary(x,y) && bVisited[x][y] == false)
{
bVisited[x][y] = true;
Path[index] = Map[x][y];
if(DFS(x,y,index+1))
return true;
bVisited[x][y] = false;
}
}
}
else
{
for(int k = 0; k <6; k++)
{
int x = Move1[k][0]+i; int y = Move1[k][1]+j;
if(InBoundary(x,y) && bVisited[x][y] == false)
{
bVisited[x][y] = true;
Path[index] = Map[x][y];
if(DFS(x,y,index+1))
return true;
bVisited[x][y] = false;
}
}
}
return false;
}
int main()
{
while(scanf("%d",&R)==1 && R!=0)
{
scanf("%d",&C);
int i,j;
cnum = C*R+R/2;
getchar();
for(i = 0; i<R; i++)
{
if(i%2 == 0)
{
for(j = 0; j<C; j++)
{ scanf(" %c",&Map[i][j]); bVisited[i][j] = false;}
getchar();
}
else
{
for(j = 0; j<=C; j++)
{scanf("%c",&Map[i][j]); bVisited[i][j] = false;getchar();}
}
}
for(i = 0; i<R; i++)
{
for(j = 0; j<C+i%2; j++)
{
if(isdigit(Map[i][j]))
{
bVisited[i][j] = true;
Path[0] = Map[i][j];
if(DFS(i,j,1)) goto PRINT;
bVisited[i][j] = false;
}
}
}
PRINT: printf("%s\n",Path);
}
return 0;
}

45
HDOJ/2703_autoAC.cpp Normal file
View File

@ -0,0 +1,45 @@
# include <stdio.h>
# include <string.h>
int n ;
int dp[25][2010] ;
int p[25], sec[25] ;
int min(int a, int b){return a<b?a:b;}
int max(int a, int b){return a>b?a:b;}
int gao()
{
int ans = 0, t = 0 ;
int i, j ;
for (i = 0 ; i < n ; i++)
{
for (j = 0 ; ; j++)
{
if (j != 0) dp[i][j] += dp[i][j-1] ;
if (j > ans && dp[i][j] == 0) break ;
if (t != 0) t-- ;
else if (dp[i][j] != 0)
{
dp[i+1][j+sec[i]] += min(dp[i][j], p[i]) ;
dp[i][j] -= min(dp[i][j], p[i]) ;
t = sec[i]-1 ;
ans = max(ans, j+sec[i]) ;
}
}
}
return ans ;
}
int main ()
{
int m, i ;
while (1)
{
scanf ("%d%d", &n, &m) ;
if (n == 0 && m == 0) break ;
n = -n ;
for (i = 0 ; i < n ; i++)
scanf ("%d%d", &p[i], &sec[i]) ;
memset (dp, 0, sizeof(dp)) ;
dp[0][0] = m ;
printf ("%d\n", gao()) ;
}
return 0 ;
}

92
HDOJ/2704_autoAC.cpp Normal file
View File

@ -0,0 +1,92 @@
#include<stdio.h>
#include<string.h>
#include<algorithm>
#define MAXN 210
#define MAXD 40010
int N, W, H, dep[4 * MAXD], ml[4 * MAXD], cnt[4 * MAXD], len[4 * MAXD];
struct Seg
{
int x, y1, y2, c;
bool operator < (const Seg &t) const
{
if(x == t.x) return c < t.c;
return x < t.x;
}
Seg(){}
Seg(int _x, int _y1, int _y2, int _c) : x(_x), y1(_y1), y2(_y2), c(_c){}
}seg[MAXN];
void build(int cur, int x, int y)
{
int mid = x + y >> 1, ls = cur << 1, rs = cur << 1 | 1;
cnt[cur] = dep[cur] = len[cur] = 0, ml[cur] = y - x + 1;
if(x == y) return ;
build(ls, x, mid), build(rs, mid + 1, y);
}
void init()
{
int i, x1, x2, y1, y2;
scanf("%d%d", &W, &H);
for(i = 0; i < N; i ++)
{
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
seg[i << 1] = Seg(x1, y1, y2, 1), seg[i << 1 | 1] = Seg(x2, y1, y2, -1);
}
std::sort(seg, seg + 2 * N);
build(1, 1, H);
}
void update(int cur, int x, int y)
{
int ls = cur << 1, rs = cur << 1 | 1;
if(dep[ls] > dep[rs]) dep[cur] = dep[ls], ml[cur] = ml[ls];
else if(dep[rs] > dep[ls]) dep[cur] = dep[rs], ml[cur] = ml[rs];
else dep[cur] = dep[ls], ml[cur] = ml[ls] + ml[rs];
dep[cur] += cnt[cur];
if(cnt[cur]) len[cur] = y - x + 1;
else len[cur] = len[ls] + len[rs];
}
void refresh(int cur, int x, int y, int s, int t, int c)
{
int mid = x + y >> 1, ls = cur << 1, rs = cur << 1 | 1;
if(x >= s && y <= t)
{
cnt[cur] += c;
if(c > 0) ++ dep[cur], len[cur] = y - x + 1;
else
{
-- dep[cur];
if(cnt[cur]) len[cur] = y - x + 1;
else
{
if(x == y) len[cur] = 0;
else len[cur] = len[ls] + len[rs];
}
}
return ;
}
if(mid >= s) refresh(ls, x, mid, s, t, c);
if(mid + 1 <= t) refresh(rs, mid + 1, y, s, t, c);
update(cur, x, y);
}
void solve()
{
int i, md, ans, area;
area = md = ans = 0;
seg[2 * N].x = seg[2 * N - 1].x;
for(i = 0; i < 2 * N; i ++)
{
refresh(1, 1, H, seg[i].y1 + 1, seg[i].y2, seg[i].c);
area += len[1] * (seg[i + 1].x - seg[i].x);
if(dep[1] > md) md = dep[1], ans = ml[1] * (seg[i + 1].x - seg[i].x);
else if(dep[1] == md) ans += ml[1] * (seg[i + 1].x - seg[i].x);
}
printf("%d %d %d\n", W * H - area, md, ans);
}
int main()
{
while(scanf("%d", &N), N)
{
init();
solve();
}
return 0;
}

49
HDOJ/2707_autoAC.cpp Normal file
View File

@ -0,0 +1,49 @@
# include <stdio.h>
# include <string.h>
char str[110] ;
char tab[] = " ABCDEFGHIJKLMNOPQRSTUVWXYZ',-.?" ;
int cnt, label[1100] ;
void gao()
{
int i, sp = 0 ;
for (i = 0 ; str[i] ; i++)
{
if (str[i] != ' ' && sp != 0)
label[cnt++] = ((sp&1)?0:1),
sp = 0 ;
else if (str[i] == ' ') sp++ ;
}
}
void Print()
{
int i, j, buff ;
for (i = 0 ; i < cnt ; i+= 5)
{
buff = 0 ;
for (j = 0 ;j < 5 ; j++)
{
if (i+j>=cnt) label[i+j] = 0 ;
buff = buff * 2 + label[i+j] ;
}
putchar (tab[buff]) ;
}
printf("\n") ;
}
int main ()
{
gets (str) ;
while (1)
{
cnt = 0 ;
if (strcmp(str, "#") == 0) break ;
while (1)
{
if (strcmp(str, "*") == 0) break ;
gao() ;
gets (str) ;
}
Print() ;
gets (str) ;
}
return 0 ;
}

73
HDOJ/2708_autoAC.cpp Normal file
View File

@ -0,0 +1,73 @@
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
int main()
{
int i,j,len,flag[28],rear[300];
int top;
char str[5][74];
while(gets(str[1]))
{
gets(str[2]);
gets(str[3]);
gets(str[4]);
memset(flag,0,sizeof(flag));
for(i=1;i<=4;i++)
{
len=strlen(str[i]);
for(j=0;j<len;j++)
{
if(str[i][j]>='A'&&str[i][j]<='Z')
{
flag[str[i][j]-'A']++;
}
}
}
top=0;
for(i=0;i<26;i++)
{
if(top<flag[i])
{
top=flag[i];
}
}
memset(rear,0,sizeof(rear));
for(i=top;i>0;i--)
{
for(j=25;j>=0;j--)
{
if(flag[j]>=i)
{
rear[i]=j;
break;
}
}
}
for(i=top;i>0;i--)
{
for(j=0;j<26&&j<=rear[i];j++)
{
if(flag[j]>=i)
{
printf("*");
}
else
{
printf(" ");
}
if(j<25&&j<rear[i])
{
printf(" ");
}
}
printf("\n");
}
for(i=0;i<25;i++)
{
printf("%c ",i+'A');
}
printf("Z\n");
}
return (0);
}

24
HDOJ/2709_autoAC.cpp Normal file
View File

@ -0,0 +1,24 @@
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;
long long dp[1000001];
int main()
{
int n,i,j;
while(scanf("%d",&n)!=EOF)
{
memset(dp,0,sizeof(dp)); dp[0]=1;
for(i=1;i<=n;i*=2)
{
for(j=i;j<=n;j++)
{
dp[j]+=dp[j-i];
dp[j]%=1000000000;
}
}
printf("%lld\n",dp[n]);
}
return 0;
}

56
HDOJ/2710_autoAC.cpp Normal file
View File

@ -0,0 +1,56 @@
#include<iostream>
#include<cmath>
using namespace std;
#define MAX 2270
int data[MAX];
int j;
void Judge(int a)
{
int i;
int tmp=sqrt(double(a))+1;
for(i=2;i<=tmp;i++)
{
if(a%i==0)
return;
}
data[j]=a;
j++;
return;
}
void Set()
{
int i;
j=1;
data[0]=1;
data[1]=2;
j++;
for(i=3;i<=20010;i++)
Judge(i);
}
int main()
{
Set();
int n,tmp,Max,result,num,i;
while(cin>>n)
{
result=0;
while(n--)
{
cin>>tmp;
for(i=0;i<2263;i++)
{
if(data[i]==tmp||(data[i]<tmp&&tmp%data[i]==0))
Max=data[i];
if(data[i]>tmp)
break;
}
if(result<Max)
{
result=Max;
num=tmp;
}
}
cout<<num<<endl;
}
return 0;
}

40
HDOJ/2711_autoAC.cpp Normal file
View File

@ -0,0 +1,40 @@
#include<stdio.h>
#include<iostream>
#include<stdlib.h>
#include<algorithm>
#include<math.h>
#include<iomanip>
#include<time.h>
#include<string.h>
#include<queue>
#include<string>
#include<vector>
using namespace std;
int p[9000];
int ans[9000];
int main(){
int n;
while(~scanf("%d",&n)){
memset(p,0,sizeof(p));
int i,cas,t=-1;
for(i=2;i<=n;i++){
scanf("%d",p+i);
}
for(cas=1;cas<=n;cas++){
t=-1;
for(i=2;i<=n;i++){
if(p[i]==0){
t=i;
}
}
if(t==-1)
t=1;
ans[t]=cas;
for(i=t;i<=n;i++)
p[i]--;
}
for(i=1;i<=n;i++)
printf("%d\n",ans[i]);
}
return 0;
}

41
HDOJ/2712_autoAC.cpp Normal file
View File

@ -0,0 +1,41 @@
#include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <queue>
#include <cstdlib>
#include <stack>
#include <vector>
#include <set>
#include <map>
#define LL long long
#define mod 1000000007
#define inf 0x3f3f3f3f
#define N 10010
#define clr(a) (memset(a,0,sizeof(a)))
using namespace std;
int n,k,x;
int vis[N];
int main()
{
while(scanf("%d%d",&n,&k)>0)
{
memset(vis,0,sizeof(vis));
int num=0,ans=0;
for(int i=1;i<=n;i++)
{
scanf("%d",&x);
if(!vis[x])
{
vis[x]=1;num++;
}
if(num==k)
{
memset(vis,0,sizeof(vis));
num=0;ans++;
}
}
printf("%d\n",ans+1);
}
}

32
HDOJ/2713_autoAC.cpp Normal file
View File

@ -0,0 +1,32 @@
#include<iostream>
#include<string.h>
using namespace std;
int a[150010];
int main()
{
int p,i;
while(scanf("%d",&p)!=EOF)
{
memset(a,0,sizeof(a));
for (i=1;i<=p;i++)
scanf("%d",&a[i]);
int s=0;
int x=0;
for (i=0;i<=p;i++)
{
if(x==0&&a[i]-a[i+1]<=0&&a[i+1]-a[i+2]>=0)
{
s=s+a[i+1];
x=1;
}
else
if (x==1&&a[i]-a[i+1]>=0&&a[i+1]-a[i+2]<=0)
{
s-=a[i+1];
x=0;
}
}
printf("%d\n",s);
}
return 0;
}

51
HDOJ/2714_autoAC.cpp Normal file
View File

@ -0,0 +1,51 @@
#include <iostream>
#include <algorithm>
#include <string>
#include <set>
#include <map>
#include <utility>
#include <queue>
#include <stack>
#include <list>
#include <vector>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
using namespace std;
int main ()
{
string str;
while ( cin >> str )
{
int N = str.size();
int sum = 0, ask = 0;
for ( int i = 1; i <= N; ++ i )
{
switch ( str[i-1] )
{
case 'X':
sum += (10-i+1) * 10; break;
case '?':
ask = 10-i+1; break;
default :
sum += (10-i+1) * (str[i-1] - '0'); break;
}
}
int pos = -1;
for ( int i = 0; i <= 10; ++ i )
{
if ( ( sum + ask * i ) % 11 == 0 )
{
pos = i;
break;
}
}
if ( ask != 1 && pos == 10 ) pos = -1;
if ( pos == 10 )
cout << 'X' << endl;
else
cout << pos << endl;
}
return 0;
}

41
HDOJ/2715_autoAC.cpp Normal file
View File

@ -0,0 +1,41 @@
#include<stdio.h>
#include<string.h>
typedef __int64 ll;
ll m;
ll cal(ll s,ll x)
{
return (2*s+x-1)*x;
}
ll binary_search(ll x)
{
ll left,right,mid,tmp;
left=1,right=m/2+1;
while(left<=right)
{
mid=(left+right)>>1;
tmp=cal(mid,x);
if(tmp==2*m)
return mid;
else if(tmp<2*m)
left=mid+1;
else
right=mid-1;
}
return -1;
}
int main()
{
ll i,tmp,num,cnt=1;
while(scanf("%I64d",&m)!=EOF)
{
num=0;
for(i=2;i*i<=2*m+10;i++)
{
tmp=binary_search(i);
if(tmp!=-1)
num++;
}
printf("%I64d\n",num+1);
}
return 0;
}

26
HDOJ/2716_autoAC.cpp Normal file
View File

@ -0,0 +1,26 @@
#include <stdio.h>
#include <string.h>
int main()
{
char key[28],str[84];
while(scanf("%s",key)!=EOF)
{
getchar();
gets(str);
int i,len;
len=strlen(str);
for(i=0;i<len;i++)
{
if(str[i]>='A'&&str[i]<='Z')
{
str[i]=key[str[i]-'A']-'a'+'A';
}
else if(str[i]>='a'&&str[i]<='z')
{
str[i]=key[str[i]-'a'];
}
}
printf("%s\n",str);
}
return 0;
}

58
HDOJ/2717_autoAC.cpp Normal file
View File

@ -0,0 +1,58 @@
#include <stdio.h>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <queue>
#include <stack>
#include <map>
#include <vector>
using namespace std;
int n,m;
int vis[200005];
struct node
{
int x;
int step;
};
int bfs(int n,int m)
{
int i;
queue<node>q;
node st,ed;
st.x=n;
st.step=0;
vis[st.x]=1;
q.push(st);
while(!q.empty())
{
st=q.front();
q.pop();
if(st.x==m)
return st.step;
for(i=0;i<3;i++)
{
if(i==0)
ed.x=st.x+1;
if(i==1)
ed.x=st.x-1;
if(i==2)
ed.x=st.x*2;
if(vis[ed.x] || ed.x<0 ||ed.x>100000)
continue;
vis[ed.x]=1;
ed.step=st.step+1;
q.push(ed);
}
}
}
int main()
{
while(cin>>n>>m)
{
memset(vis,0,sizeof(vis));
int ans=bfs(n,m);
cout<<ans<<endl;
}
}

49
HDOJ/2719_autoAC.cpp Normal file
View File

@ -0,0 +1,49 @@
#include <stdio.h>
#include <string.h>
int main()
{
int i;
char s[85];
while(gets(s)&&s[0]!='#')
{
int l=strlen(s);
for(i=0;i<l;i++)
{
if(s[i]==' ')
s[i]=1;
if(s[i]=='!')
s[i]=2;
if(s[i]=='$')
s[i]=3;
if(s[i]=='%')
s[i]=4;
if(s[i]=='(')
s[i]=5;
if(s[i]==')')
s[i]=6;
if(s[i]=='*')
s[i]=7;
}
for(i=0;i<l;i++)
{
if(s[i]==1)
printf("%%20");
if(s[i]==2)
printf("%%21");
if(s[i]==3)
printf("%%24");
if(s[i]==4)
printf("%%25");
if(s[i]==5)
printf("%%28");
if(s[i]==6)
printf("%%29");
if(s[i]==7)
printf("%%2a");
if(s[i]!=1 &&s[i]!=2 &&s[i]!=3 &&s[i]!=4&&s[i]!=5 &&s[i]!=6 &&s[i]!=7)
printf("%c",s[i]);
}
printf("\n");
}
return 0;
}

49
HDOJ/2721_autoAC.cpp Normal file
View File

@ -0,0 +1,49 @@
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
int aa[100000];
void convert(int a,int b)
{
char s[16];
int i=0;
for(;i<16;i++)
{
int k=a%2;
if(k==1)s[i]='1';
else if(b%2==1) s[i]='?';
else s[i]='0';
a/=2;b/=2;
}
for(i=15;i>=0;i--)
printf("%c",s[i]);
printf("\n");
}
int main()
{
int a,b,c,d;
int top=0;
while(true)
{
top=1;
cin>>a;
if(a==0) break;
cin>>b>>c>>d;
aa[0]=d;
for(int i=0;i< 65537;i++)
{
aa[top]=(a%c*d%c+b%c)%c;
d=aa[top++];
if(d==aa[0])break;
}
int result=aa[0];
int com=aa[0];
for(int i=1;i<top&&i<=65536;i++)
{
result &= aa[i];
com |=aa[i];
}
convert(result,com);
}
return 0;
}

70
HDOJ/2722_autoAC.cpp Normal file
View File

@ -0,0 +1,70 @@
#include<iostream>
#include<stdio.h>
#include<string.h>
#include<string>
#include<algorithm>
#include<map>
#include<queue>
#define INF 100000000
#define L 2520
using namespace std;
int N,M;
int d[4][2]={{0,1},{0,-1},{1,0},{-1,0}};
int dp[25][25];
struct Block
{
int a[4];
}mp[25][25];
int main()
{
int i,j,k,v;
char c;
while(cin>>N>>M,N||M)
{
memset(mp,0,sizeof(mp));
for(i=0;i<=N;i++)
{
for(j=0;j<M;j++)
{
cin>>v>>c;
if(v)
v=L/v;
if(c=='*')
mp[i][j].a[0]=mp[i][j+1].a[1]=v;
if(c=='>')
mp[i][j].a[0]=v;
if(c=='<')
mp[i][j+1].a[1]=v;
}
if(i!=N)
for(j=0;j<=M;j++)
{
cin>>v>>c;
if(v)
v=L/v;
if(c=='*')
mp[i][j].a[2]=mp[i+1][j].a[3]=v;
if(c=='v')
mp[i][j].a[2]=v;
if(c=='^')
mp[i+1][j].a[3]=v;
}
}
for(i=0;i<=N;i++)
for(j=0;j<=M;j++)
dp[i][j]=INF;
dp[0][0]=0;
for(v=0;v<40;v++)
for(i=0;i<=N;i++)
for(j=0;j<=M;j++)
for(k=0;k<4;k++)
if(mp[i][j].a[k])
if(dp[i+d[k][0]][j+d[k][1]]>dp[i][j]+mp[i][j].a[k])
dp[i+d[k][0]][j+d[k][1]]=dp[i][j]+mp[i][j].a[k];
if(dp[N][M]==INF)
cout<<"Holiday"<<endl;
else
cout<<dp[N][M]<<" blips"<<endl;
}
return 0;
}

47
HDOJ/2723_autoAC.cpp Normal file
View File

@ -0,0 +1,47 @@
# include <stdio.h>
# include <string.h>
int ACL[30], out[30][2] ;
char str[100] ;
char entity[100], right[100] ;
void gao(char s[])
{
char *p = s, op ;
int ent, rit, i, j ;
memset (ACL, 0, sizeof(ACL)) ;
while (*p)
{
sscanf (p, "%[A-Z]%c%[a-z]%*c", entity, &op, right) ;
p += strlen(entity) + strlen(right) + 2 ;
for (i = 0 ; entity[i] ; i++)
{
ent = entity[i]-'A' ;
for (rit = 0, j = 0 ; right[j] ; j++) rit |= (1<<(right[j]-'a')) ;
if (op == '+') ACL[ent] |= rit ;
else if (op == '-') ACL[ent] &= ~rit ;
else //op == '='
ACL[ent] = rit ;
}
}
}
int main ()
{
int nCase = 1 ;
int i, j, cnt ;
while (~scanf ("%s", str) && strcmp(str, "#"))
{
gao(str) ;
memset (str, 0, sizeof(str)) ;
printf ("%d:", nCase++) ;
for (i = 0, cnt = 0 ; i < 26 ; i++) if (ACL[i])
out[cnt][0] = i, out[cnt++][1] = ACL[i] ;
for (i = 0 ; i < cnt ; i++)
{
printf ("%c", out[i][0]+'A') ;
if (i==cnt-1 || (i<cnt-1 && out[i][1] != out[i+1][1]))
for (j = 0 ; j < 26 ; j++) if (out[i][1] & (1<<j))
printf ("%c", j+'a') ;
}
printf ("\n") ;
}
return 0 ;
}

4
HDOJ/2725_autoAC.cpp Normal file
View File

@ -0,0 +1,4 @@
...=...**..#...@....:.:.:..=..
______________________________
11111111112222222222
012345678901234567890123456789

72
HDOJ/2726_autoAC.cpp Normal file
View File

@ -0,0 +1,72 @@
#include<iostream>
#include<stdio.h>
#include<list>
using namespace std;
class Bookshelf;
class Book{
public:
Book(int _id,int _width):id(_id),width(_width){}
int id,width;
friend class Bookshelf;
};
class Bookshelf{
public:
Bookshelf(int w):width(w){
occupied_width=0;
}
void add(const Book &book){
shelf.push_front(book);
occupied_width += book.width;
while(occupied_width>width){
occupied_width -= (shelf.back()).width;
shelf.pop_back();
}
}
void remove(const int &id){
list<Book>::iterator i;
for(i=shelf.begin();i!=shelf.end();i++){
if(i->id == id) break;
}
if(i==shelf.end()) return;
occupied_width -= i->width;
shelf.erase(i);
}
friend ostream& operator<<(ostream &out,Bookshelf &bookshelf);
private:
list<Book> shelf;
int width;
int occupied_width;
};
ostream& operator<<(ostream &out, Bookshelf &bookshelf)
{
list<Book>::iterator i;
for(i=(bookshelf.shelf).begin();i!=(bookshelf.shelf).end();i++)
out<<" "<<i->id;
return out;
}
int main()
{
int width;
int p=1;
char cmd;
while(cin>>width,width!=-1)
{
Bookshelf bookshelf(width);
int id,w;
while(cin>>cmd)
{
if(cmd=='E') break;
else if(cmd=='R')
{
cin>>id;
bookshelf.remove(id);
}else
{
cin>>id>>w;
bookshelf.add(Book(id,w));
}
}
cout<<"PROBLEM "<<p++<<":"<<bookshelf<<endl;
}
return 0;
}

380
HDOJ/2727_autoAC.cpp Normal file
View File

@ -0,0 +1,380 @@
#include<iostream>
using namespace std;
const int size=23;
const int num=251;
int n;
int m;
int lastx,lasty;
int map[size][size];
bool link[num][num];
int posx[]={0,-1,-2,-2,-1,1,2,2,1};
int posy[]={0,2,1,-1,-2,-2,-1,1,2};
typedef class chess
{
public:
int color;
int r,c;
int connet[8];
int pc;
chess()
{
color=-1;
pc=0;
}
}PEG;
void LinePeg(PEG* peg,int i);
bool CheckWin(PEG* peg,bool flag);
int main(void)
{
while(cin>>n>>m)
{
if(!n && !m)
break;
memset(map,0,sizeof(map));
memset(link,false,sizeof(link));
PEG* peg=new PEG[m+1];
for(int i=1;i<=m;i++)
{
int x,y;
cin>>x>>y;
map[x][y]=i;
peg[i].r=x;
peg[i].c=y;
if(i%2)
peg[i].color=1;
else
peg[i].color=0;
if(i==m)
{
lastx=x;
lasty=y;
}
LinePeg(peg,i);
}
if(CheckWin(peg,true) && !CheckWin(peg,false))
cout<<"yes"<<endl;
else
cout<<"no"<<endl;
}
return 0;
}
void LinePeg(PEG* peg,int i)
{
int color=peg[i].color;
for(int k=1;k<=8;k++)
{
int r=peg[i].r+posx[k];
int c=peg[i].c+posy[k];
if(r>=0 && r<=n && c>=0 && c<=n)
{
if(map[r][c] && peg[ map[r][c] ].color==color)
{
switch(k)
{
case 1:
{
if(link[ map[r][c-2] ][ map[r+1][c] ])
break;
if(c-3>=0 && link[ map[r][c-3] ][ map[r+1][c-1] ])
break;
if(c+1<=n && link[ map[r][c-1] ][ map[r+1][c+1] ])
break;
if(r-1>=0)
{
if(link[ map[r-1][c-2] ][ map[r+1][c-1] ])
break;
if(link[ map[r-1][c-1] ][ map[r+1][c] ])
break;
if(link[ map[r-1][c] ][ map[r+1][c-1] ])
break;
}
if(r+2<=n)
{
if(link[ map[r+2][c-2] ][ map[r][c-1] ])
break;
if(link[ map[r+2][c-1] ][ map[r][c-2] ])
break;
if(link[ map[r+2][c] ][ map[r][c-1] ])
break;
}
int a=map[peg[i].r][peg[i].c];
int b=map[r][c];
peg[a].connet[peg[a].pc++]=b;
peg[b].connet[peg[b].pc++]=a;
link[a][b]=link[b][a]=true;
break;
}
case 2: //60搴逛
{
if(link[ map[r][c-1] ][ map[r+2][c] ])
break;
if(r-1>=0 && link[ map[r-1][c-1] ][ map[r+1][c] ])
break;
if(r+3<=n && link[ map[r+1][c-1] ][ map[r+3][c] ])
break;
if(c-2>=0)
{
if(link[ map[r][c-2] ][ map[r+1][c] ])
break;
if(link[ map[r+1][c-2] ][ map[r+2][c] ])
break;
if(link[ map[r+2][c-2] ][ map[r+1][c] ])
break;
}
if(c+1<=n)
{
if(link[ map[r][c-1] ][ map[r+1][c+1] ])
break;
if(link[ map[r+1][c-1] ][ map[r][c+1] ])
break;
if(link[ map[r+1][c-1] ][ map[r+2][c+1] ])
break;
}
int a=map[peg[i].r][peg[i].c];
int b=map[r][c];
peg[a].connet[peg[a].pc++]=b;
peg[b].connet[peg[b].pc++]=a;
link[a][b]=link[b][a]=true;
break;
}
case 3: //120搴逛
{
if(link[ map[r][c+1] ][ map[r+2][c] ])
break;
if(r-1>=0 && link[ map[r-1][c+1] ][ map[r+1][c] ])
break;
if(r+3<=n && link[ map[r+1][c+1] ][ map[r+3][c] ])
break;
if(c-1>=0)
{
if(link[ map[r][c-1] ][ map[r+1][c+1] ])
break;
if(link[ map[r+1][c-1] ][ map[r][c+1] ])
break;
if(link[ map[r+2][c-1] ][ map[r+1][c+1] ])
break;
}
if(c+2<=n)
{
if(link[ map[r+1][c] ][ map[r][c+2] ])
break;
if(link[ map[r+2][c] ][ map[r+1][c+2] ])
break;
if(link[ map[r+1][c] ][ map[r+2][c+2] ])
break;
}
int a=map[peg[i].r][peg[i].c];
int b=map[r][c];
peg[a].connet[peg[a].pc++]=b;
peg[b].connet[peg[b].pc++]=a;
link[a][b]=link[b][a]=true;
break;
}
case 4: //150搴逛
{
if(link[ map[r][c+2] ][ map[r+1][c] ])
break;
if(c-1>=0 && link[ map[r+1][c-1] ][ map[r][c+1] ])
break;
if(c+3<=n && link[ map[r+1][c+1] ][ map[r][c+3] ])
break;
if(r-1>=0)
{
if(link[ map[r-1][c] ][ map[r+1][c+1] ])
break;
if(link[ map[r-1][c+1] ][ map[r+1][c] ])
break;
if(link[ map[r-1][c+2] ][ map[r+1][c+1] ])
break;
}
if(r+2<=n)
{
if(link[ map[r][c+1] ][ map[r+2][c] ])
break;
if(link[ map[r][c+1] ][ map[r+2][c+2] ])
break;
if(link[ map[r][c+2] ][ map[r+2][c+1] ])
break;
}
int a=map[peg[i].r][peg[i].c];
int b=map[r][c];
peg[a].connet[peg[a].pc++]=b;
peg[b].connet[peg[b].pc++]=a;
link[a][b]=link[b][a]=true;
break;
}
case 5: //210搴逛
{
if(link[ map[r-1][c] ][ map[r][c+2] ])
break;
if(c-1>=0 && link[ map[r-1][c-1] ][ map[r][c+1] ])
break;
if(c+3<=n && link[ map[r-1][c+1] ][ map[r][c+3] ])
break;
if(r-2>=0)
{
if(link[ map[r-2][c] ][ map[r][c+1] ])
break;
if(link[ map[r-2][c+1] ][ map[r][c+2] ])
break;
if(link[ map[r-2][c+2] ][ map[r][c+1] ])
break;
}
if(r+1<=n)
{
if(link[ map[r][c] ][ map[r-1][c+1] ])
break;
if(link[ map[r+1][c+1] ][ map[r-1][c] ])
break;
if(link[ map[r+1][c+2] ][ map[r-1][c+1] ])
break;
}
int a=map[peg[i].r][peg[i].c];
int b=map[r][c];
peg[a].connet[peg[a].pc++]=b;
peg[b].connet[peg[b].pc++]=a;
link[a][b]=link[b][a]=true;
break;
}
case 6: //240搴逛
{
if(link[ map[r-2][c] ][ map[r][c+1] ])
break;
if(r-3>=0 && link[ map[r-3][c] ][ map[r-1][c+1] ])
break;
if(r+1<=n && link[ map[r-1][c] ][ map[r+1][c+1] ])
break;
if(c-1>=0)
{
if(link[ map[r-2][c-1] ][ map[r-1][c+1] ])
break;
if(link[ map[r-1][c-1] ][ map[r][c+1] ])
break;
if(link[ map[r][c-1] ][ map[r-1][c+1] ])
break;
}
if(c+2<=n)
{
if(link[ map[r-1][c] ][ map[r-2][c+2] ])
break;
if(link[ map[r-2][c] ][ map[r-1][c+2] ])
break;
if(link[ map[r-1][c] ][ map[r][c+2] ])
break;
}
int a=map[peg[i].r][peg[i].c];
int b=map[r][c];
peg[a].connet[peg[a].pc++]=b;
peg[b].connet[peg[b].pc++]=a;
link[a][b]=link[b][a]=true;
break;
}
case 7: //300搴逛
{
if(link[ map[r-2][c] ][ map[r][c-1] ])
break;
if(r-3>=0 && link[ map[r-3][c] ][ map[r-1][c-1] ])
break;
if(r+1<=n && link[ map[r-1][c] ][ map[r+1][c-1] ])
break;
if(c-2>=0)
{
if(link[ map[r-2][c-2] ][ map[r-1][c] ])
break;
if(link[ map[r-1][c-2] ][ map[r-2][c] ])
break;
if(link[ map[r][c-2] ][ map[r-1][c] ])
break;
}
if(c+1<=n)
{
if(link[ map[r-1][c-1] ][ map[r-2][c+1] ])
break;
if(link[ map[r][c-1] ][ map[r-1][c+1] ])
break;
if(link[ map[r-1][c-1] ][ map[r][c+1] ])
break;
}
int a=map[peg[i].r][peg[i].c];
int b=map[r][c];
peg[a].connet[peg[a].pc++]=b;
peg[b].connet[peg[b].pc++]=a;
link[a][b]=link[b][a]=true;
break;
}
case 8: //330搴逛
{
if(link[ map[r][c-2] ][ map[r-1][c] ])
break;
if(c-3>=0 && link[ map[r][c-3] ][ map[r-1][c-1] ])
break;
if(c+1<=n && link[ map[r][c-1] ][ map[r-1][c+1] ])
break;
if(r-2>=0)
{
if(link[ map[r-2][c-2] ][ map[r][c-1] ])
break;
if(link[ map[r-2][c-1] ][ map[r][c-2] ])
break;
if(link[ map[r-2][c] ][ map[r][c-1] ])
break;
}
if(r+1<=n)
{
if(link[ map[r-1][c-1] ][ map[r+1][c-2] ])
break;
if(link[ map[r-1][c-1] ][ map[r+1][c] ])
break;
if(link[ map[r-1][c] ][ map[r+1][c-1] ])
break;
}
int a=map[peg[i].r][peg[i].c];
int b=map[r][c];
peg[a].connet[peg[a].pc++]=b;
peg[b].connet[peg[b].pc++]=a;
link[a][b]=link[b][a]=true;
break;
}
}
}
}
}
return;
}
bool CheckWin(PEG* peg,bool flag)
{
int NUM;
if(!flag)
NUM=map[lastx][lasty];
for(int k=0;k<=n;k++)
{
int p=map[0][k];
if(p && p!=NUM && peg[p].color==1)
{
int queue[num];
bool vist[num]={false};
int head=0;
int tail=0;
queue[tail++]=p;
vist[p]=true;
while(head<tail)
{
int s=queue[head++];
if(peg[s].r==n)
return true;
for(int i=0;i<peg[s].pc;i++)
{
int x=peg[s].connet[i];
if(!vist[x])
{
vist[x]=true;
if(!flag && x==NUM)
continue;
queue[tail++]=x;
}
}
}
}
}
return false;
}

39
HDOJ/2728_autoAC.cpp Normal file
View File

@ -0,0 +1,39 @@
#include<stdio.h>
double max(double a,double b)
{
if(a>b)
return a;
else
return b;
}
double min(double a,double b)
{
if(a>b)
return b;
else
return a;
}
int main()
{
int a,b,c,d,z;
double x1,x2,x3,x4,y1,y2;
while(scanf("%d%d%d%d",&a,&b,&c,&d)!=EOF&&(a!=0||b!=0||c!=0||d!=0))
{
if(c>=a&&d>=b)
printf("100%%\n");
else if(c>=b&&d>=a)
printf("100%%\n");
else
{
x1=c*1.0/a;
x2=d*1.0/b;
y1=min(x1,x2);
x3=c*1.0/b;
x4=d*1.0/a;
y2=min(x3,x4);
z=max(y1,y2)*100;
printf("%d%%\n",z);
}
}
return 0;
}

80
HDOJ/2729_autoAC.cpp Normal file
View File

@ -0,0 +1,80 @@
#include <stdio.h>
#include <string.h>
#define oo 100000
bool dfs(int, int);
int n,m,mini;
bool finished[14];
struct CLASS {
char name[8];
int time,preNum;
int prerequisites[13];
} subject[15];
bool permit(int num) {
int i;
for(i=0; i<subject[num].preNum && finished[subject[num].prerequisites[i]]; i++);
if(i == subject[num].preNum) return true;
return false;
}
bool selectAndDfs(int total, int elect, int from, int que[], int result[], int lev, int semester) {
int i;
if(total-from < elect) return false;
if(from == total && elect == 0) {
for(i=0; i<m; i++) finished[result[i]] = true;
dfs(lev+m, semester+1);
for(i=0; i<m; i++) finished[result[i]] = false;
return true;
}
for(i=from; i<total; i++) {
result[m-elect] = que[i];
selectAndDfs(total, elect-1, i+1, que, result, lev, semester);
}
return true;
}
bool dfs(int lev, int semester) {
if(semester-1 >= mini) return false;
if(lev == n) {
if(semester-1 < mini) mini = semester-1;
return true;
}
int i,tn=0,que[15];
for(i=0; i<n; i++) if(!finished[i] && permit(i) && (subject[i].time & (1<<semester%2)) != 0) que[tn++] = i;
if(tn <= m) {
for(i=0; i<tn; i++) finished[que[i]] = true;
dfs(lev+tn,semester+1);
for(i=0; i<tn; i++) finished[que[i]] = false;
}
else {
int temp[15];
selectAndDfs(tn,m,0,que,temp,lev,semester);
}
return false;
}
int main() {
while(scanf("%d%d", &n, &m) == 2 && !(n == -1 && m == -1)) {
int i,j,k,p,t;
for(i=0; i<n; i++) {
scanf("%s", &subject[i].name);
subject[i].time = subject[i].preNum = 0;
}
for(i=0; i<n; i++) {
char s[10];
scanf("%s", s);
for(j=0; j<n && strcmp(s, subject[j].name) != 0; j++);
scanf("%s", s);
if(s[0] == 'B') subject[j].time = 3;
else if(s[0] == 'S') subject[j].time = 1;
else subject[j].time = 2;
scanf("%d", &t);
for(k=0; k<t; k++) {
scanf("%s", s);
for(p=0; p<n && strcmp(s, subject[p].name) != 0; p++);
subject[j].prerequisites[subject[j].preNum++] = p;
}
}
memset(finished, 0, sizeof(finished));
mini = oo;
dfs(0,1);
printf("The minimum number of semesters required to graduate is %d.\n", mini);
}
return 0;
}

53
HDOJ/2730_autoAC.cpp Normal file
View File

@ -0,0 +1,53 @@
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define N 13
int cmp(const void *p, const void *q)
{
return *(int *)p > *(int *)q ? -1 : 1;
}
int main()
{
int i, j;
int n, grey, count, max, colors[N];
while(scanf("%d", &n) && n)
{
memset(colors, 0, sizeof(colors));
max = 0;
for(i=0; i<n; i++)
{
scanf("%d", &colors[i]);
if(colors[i] > max)
max = colors[i];
}
scanf("%d", &grey);
if(max % 50)
count = max / 50 + 1;
else count = max / 50;
for(i=0; i<n; i++)
{
colors[i] = count * 50 - colors[i];
}
qsort(colors, n, sizeof(colors[0]), cmp);
while(1)
{
if(colors[2] == 0 && grey > 0)
{
count++;
for(i=0; i<n; i++)
colors[i] += 50;
}
grey --;
if(grey <= 0)
break;
else {
colors[0]--;
colors[1]--;
colors[2]--;
qsort(colors, n, sizeof(colors[0]), cmp);
}
}
printf("%d\n", count);
}
return 0;
}

23
HDOJ/2731_autoAC.cpp Normal file
View File

@ -0,0 +1,23 @@
#include<iostream>
using namespace std;
int main()
{
int cases, x = 1;
cin>>cases;
while (cases--) {
int a, b, c, d;
cin>>a>>b>>c>>d;
printf("Problem set %d: %d / %d, base 7 digits %d through %d: ", x++, a, b, c, d);
int i;
a %= b;
for (i = 0; i <= d; ++i) {
a *= 7;
if (i >= c) {
printf("%d", a / b);
}
a %= b;
}
printf("\n");
}
return 0;
}

158
HDOJ/2732_autoAC.cpp Normal file
View File

@ -0,0 +1,158 @@
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <queue>
#define RE(x) ((x)^1)
#define CP(x) ((x)+500)
#define INF 0x3fffffff
using namespace std;
int N, M, MM, dis[1000], head[1000], idx;
const int source = 980, sink = 981;
char G[25][25], S[25][25];
struct Edge
{
int v, cap, next;
}e[20000];
void init()
{
idx = -1;
memset(head, 0xff, sizeof (head));
}
inline int to(int x, int y)
{
return x*M+y;
}
inline bool out(int x, int y)
{
int u = x+1, d = N-x, l = y+1, r = M-y;
int dist = min(u, min(d, min(l, r)));
return dist <= MM;
}
inline bool judge(int x, int y)
{
if (x < 0 || x >= N || y < 0 || y >= M) {
return false;
}
else if (!G[x][y]) {
return false;
}
return true;
}
void insert(int a, int b, int c)
{
++idx;
e[idx].v = b, e[idx].cap = c;
e[idx].next = head[a], head[a] = idx;
}
void build(int x, int y)
{
int xx, yy;
if (G[x][y]) {
insert(to(x, y), CP(to(x,y)), G[x][y]);
insert(CP(to(x, y)), to(x,y), G[x][y]);
if (out(x, y)) {
insert(CP(to(x, y)), sink, INF);
insert(sink, CP(to(x, y)), 0);
}
else {
for (int i = -MM; i <= MM; ++i) {
for (int j = -(MM-abs(i)); j <= (MM-abs(i)); ++j) {
xx = x + i, yy = y + j;
if (judge(xx, yy) && !(x == xx && y == yy)) {
insert(CP(to(x, y)), to(xx, yy), G[x][y]);
insert(to(xx, yy), CP(to(x, y)), 0);
}
}
}
}
}
}
bool spfa(int u)
{
queue<int>q;
memset(dis, 0xff, sizeof (dis));
dis[u] = 0;
q.push(u);
while (!q.empty()) {
u = q.front();
q.pop();
for (int i = head[u]; i != -1; i = e[i].next) {
if (dis[e[i].v] == -1 && e[i].cap > 0) {
dis[e[i].v] = dis[u] + 1;
q.push(e[i].v);
}
}
}
return dis[sink] != -1;
}
int dfs(int u, int flow)
{
if (u == sink) {
return flow;
}
int tf = 0, sf;
for (int i = head[u]; i != -1; i = e[i].next) {
if (dis[u]+1 == dis[e[i].v] && e[i].cap > 0 && (sf = dfs(e[i].v, min(flow-tf, e[i].cap)))) {
e[i].cap -= sf, e[RE(i)].cap += sf;
tf += sf;
if (tf == flow) {
return flow;
}
}
}
if (!tf) {
dis[u] = -1;
}
return tf;
}
int dinic()
{
int ans = 0;
while (spfa(source)) {
ans += dfs(source, INF);
}
return ans;
}
int main()
{
int T, ca = 0, ans;
scanf("%d", &T);
while (T--) {
init();
ans = 0;
scanf("%d %d", &N, &MM);
for (int i = 0; i < N; ++i) {
scanf("%s", G[i]);
}
M = strlen(G[0]);
for (int i = 0; i < N; ++i) {
for (int j = 0; j < M; ++j) {
G[i][j] -= '0';
build(i, j);
}
}
for (int i = 0; i < N; ++i) {
scanf("%s", S[i]);
for (int j = 0; j < M; ++j) {
if (S[i][j] == 'L') {
++ans;
insert(source, to(i, j), 1);
insert(to(i, j), source, 0);
}
}
}
ans -= dinic();
printf("Case #%d: ", ++ca);
if (!ans) {
puts("no lizard was left behind.");
}
else if (ans == 1){
printf("%d lizard was left behind.\n", ans);
}
else {
printf("%d lizards were left behind.\n", ans);
}
}
return 0;
}

144
HDOJ/2733_autoAC.cpp Normal file
View File

@ -0,0 +1,144 @@
#include <stdio.h>
#include <string.h>
char s[81];
int l;
int Dig(char c)
{
if (c >= '0' && c <= '9')
{
return 1;
}
return 0;
}
int Upper(char c)
{
if (c >= 'A' && c <= 'Z')
{
return 1;
}
return 0;
}
int Lower(char c)
{
if (c >= 'a' && c <= 'z')
{
return 1;
}
return 0;
}
int Char(char c)
{
if (Upper(c) || Lower(c))
{
return 1;
}
return 0;
}
int Punc(char c)
{
if (Dig(c) || Char(c) || c == ' ')
{
return 0;
}
return 1;
}
int Iso(char c)
{
if (c == 'A' || c == 'a' || c == 'I')
{
return 1;
}
return 0;
}
int check1()
{
int i;
for (i = 0; i < l - 1; i++)
{
if(Upper(s[i]) && Upper(s[i + 1]))
return 0;
}
return 1;
}
int check2()
{
int i;
for (i = 0; i < l - 1; i++)
{
if ((Char(s[i]) && Dig(s[i + 1])) || (Char(s[i + 1]) && Dig(s[i])))
return 0;
}
return 1;
}
int check3()
{
int i;
if (l == 1)
{
if (Iso(s[0]))
{
return 1;
}
return 0;
}
if (s[1] == ' '&& Iso(s[0]) == 0 && s[0] != ' ')
return 0;
if (s[l - 2] == ' ' && Iso(s[l - 1]) == 0 && s[l - 1] != ' ')
return 0;
for (i = 1; i < l - 1; i++)
{
if(s[i] != ' ' && s[i - 1] == ' ' && s[i + 1] == ' ' && Iso(s[i]) == 0)
return 0;
}
return 1;
}
int check4()
{
int i;
for (i = 0; i < l - 1; i++)
{
if(Punc(s[i]) && Punc(s[i + 1]) && s[i] != '\"' && s[i + 1] != '\"')
return 0;
}
return 1;
}
int check()
{
if (check1() == 0)
{
return 0;
}
if (check2() == 0)
{
return 0;
}
if (check3() == 0)
{
return 0;
}
if (check4() == 0)
{
return 0;
}
return 1;
}
int main()
{
while (1)
{
gets(s);
if (strcmp(s, "#") == 0)
{
break;
}
l = strlen(s);
if (check())
{
printf("OK\n");
}
else
{
printf("suspicious\n");
}
}
}

25
HDOJ/2734_autoAC.cpp Normal file
View File

@ -0,0 +1,25 @@
#include <stdio.h>
#include <string.h>
int main()
{
char a[300];
int i;
int b[300];
while(gets(a) &&a[0]!='#')
{
memset(b,0,sizeof(b));
int l=strlen(a);
for(i=0;i<l;i++)
{
if(a[i]!=' ')
b[i]=a[i]-'A'+1;
else
b[i]=0;
}
int sum=0;
for(i=0;i<l;i++)
sum+=b[i]*(i+1);
printf("%d\n",sum);
}
return 0;
}

21
HDOJ/2735_autoAC.cpp Normal file
View File

@ -0,0 +1,21 @@
#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;
int main(){
char str[100];
while(scanf("%s", str)&&str[0]!='#'){
int flag=1, ans=0, len=strlen(str), t=0, i;
for(i=0; i<len; i++){
switch(str[i]){
case '/':if(flag)ans+=100;flag=0;break;
case '\\':t=100;break;
case '.':ans+=t+100;t=0;flag=1;break;
case '_':break;
case '|':if(flag)ans+=50;flag=0;t=50;break;
}
}
printf("%d\n", (ans+t)/len);
}
return 0;
}

44
HDOJ/2736_autoAC.cpp Normal file
View File

@ -0,0 +1,44 @@
#include<stdio.h>
#include<string.h>
int main()
{
int i,j,len,k,z,l,flag;
char ch[100];
char s[100][2];
while(gets(ch))
{
memset(s,0,sizeof(s));
flag=0;
if(ch[0]=='*')
break;
len=strlen(ch);
for(i=1;i<len-1;i++)
{
k=0;
for(j=0;j+i<len;j++)
{
s[k][0]=ch[j];
s[k][1]=ch[j+i];
k++;
}
for(z=0;z<k;z++)
for(l=z+1;l<k;l++)
{
if(s[z][0]==s[l][0]&&s[z][1]==s[l][1])
{flag=1;break;}
}
if(flag==1)
break;
}
if(flag==1)
{
printf("%s is NOT surprising.\n",ch);
}
else
{
printf("%s is surprising.\n",ch);
}
memset(ch,0,sizeof(ch));
}
return 0;
}

113
HDOJ/2738_autoAC.cpp Normal file
View File

@ -0,0 +1,113 @@
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
using namespace std;
#define maxn 101
struct Term
{
int s[maxn];
char ch[maxn];
}term[maxn];
string word[maxn];
string st;
int n, m, termnum[maxn];
bool input()
{
int i = 0;
while (1)
{
getline(cin, word[i]);
if (word[i] == "#")
return false;
if (word[i] == "*")
break;
i++;
}
n = i;
return true;
}
void getterm(string &a, Term &term, int &num)
{
int i = 0, j = 0;
while (i < a.length())
{
if (a[i] != '-' && a[i] != '+')
{
term.ch[j] = a[i];
term.s[j] = 1;
i++;
j++;
continue;
}
if (a[i] == '-')
term.s[j] = 0;
if (a[i] == '+')
term.s[j] = 2;
i++;
term.ch[j] = a[i];
i++;
j++;
}
num = j;
}
void maketerms()
{
int temp;
int i = 0;
temp = st.find('|');
while (temp != string::npos)
{
string sub = st.substr(0, temp);
getterm(sub, term[i], termnum[i]);
st.erase(0, temp + 1);
i++;
temp = st.find('|');
}
getterm(st, term[i], termnum[i]);
m = i + 1;
}
bool match(string &word, Term &term, int &num)
{
for (int i = 0; i < num; i++)
if (term.s[i] == 0 && word.find(term.ch[i]) != string::npos)
return false;
for (int i = 0; i < num; i++)
if (term.s[i] == 2 && word.find(term.ch[i]) == string::npos)
return false;
for (int i = 0; i < num; i++)
if (term.s[i] == 1 && word.find(term.ch[i]) != string::npos)
return true;
return false;
}
int main()
{
while (1)
{
if (!input())
break;
sort(word, word + n);
while (getline(cin, st) && st != "**")
{
bool found = false;
maketerms();
for (int i = 0; i < n; i++)
{
for (int j = 0; j < m; j++)
if (match(word[i], term[j], termnum[j]))
{
found = true;
cout << word[i] << endl;
break;
}
if (found)
break;
}
if (!found)
cout << "NONE" << endl;
}
cout << "$" << endl;
}
return 0;
}

96
HDOJ/2739_autoAC.cpp Normal file
View File

@ -0,0 +1,96 @@
#include<stdio.h>
#include "math.h"
int e[2001][2];//杈[0],to.[1]next;
int a[1001][5];//[0],ID,[1]next;2x3y4z
int c[1001];
int cnum;
int max;int m;
bool sign[1001];
int n;//圭扮
int en;//杈圭扮
void initt();
void init();
int DFS(int s);
int eq(int x);
int main()
{
while(1)
{
scanf("%d",&n);
if(n==0)return 0;
initt();
init();
int min=1000;
int i;
for(i=1;i<=n;i++)//n娆DFS
{
max=0;
m=0;
DFS(i);
if(max<min)min=max,c[1]=a[i][0],cnum=1;
else if(max==min)cnum++,c[cnum]=a[i][0];
else ;
}
if(cnum==1)printf("%d",c[1]);
else
{
if(c[1]>c[2])printf("%d %d",c[2],c[1]);
else printf("%d %d",c[1],c[2]);
}
printf("\n");
}
}
int DFS(int s)
{
if(sign[s])return 0;
if((!e[a[s][1]][1])&&sign[e[a[s][1]][0]]){
if(max<m){max=m; return 0;}
else return 0;}
m++;
sign[s]=true;
int next=a[s][1];
while(next)
{
DFS(e[next][0]);
next=e[next][1];
}
m--;sign[s]=false;
return 0;
}
void initt()
{
int i;
cnum=0;
for(i=0;i<=n;i++)
a[i][1]=0;
for(i=0;i<=2*n;i++)
e[i][1]=0;
}
void init()
{
int k=0;int en=0;
k++;
int id;int x;int y;int z;
scanf("%d%d%d%d",&id,&x,&y,&z);
a[k][0]=id;a[k][2]=x,a[k][3]=y,a[k][4]=z;
while(k<n)
{
k++;
scanf("%d%d%d%d",&id,&x,&y,&z);
a[k][0]=id;a[k][2]=x,a[k][3]=y,a[k][4]=z;
int ee;ee=eq(k);
en++;e[en][0]=ee;e[en][1]=a[k][1];a[k][1]=en;
en++;e[en][0]=k;e[en][1]=a[ee][1];a[ee][1]=en;
}
}
int eq(int x)
{
int i;double min=10000;int xx;
for(i=1;i<x;i++)
{
double temp=((a[x][3]-a[i][3])*(a[x][3]-a[i][3])+(a[x][4]-a[i][4])*(a[x][4]-a[i][4])+(a[x][2]-a[i][2])*(a[x][2]-a[i][2]));
double val=sqrt(temp);
if(val<min)min=val,xx=i;
}
return xx;
}

16
HDOJ/2740_autoAC.cpp Normal file
View File

@ -0,0 +1,16 @@
#include <cstdio>
#include <cmath>
int main()
{
double B,N;
int A;
while(scanf("%lf%lf",&B,&N)&&(B!=0.0||N!=0.0))
{
A=pow(B,1/N);
if((B-pow(A,N))<(pow(A+1,N)-B))
printf("%d\n",A);
else
printf("%d\n",A+1);
}
return 0;
}

58
HDOJ/2752_autoAC.cpp Normal file
View File

@ -0,0 +1,58 @@
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std ;
#define M 100000 + 10
#define eps 1e-4
int A[M] ;
int n ;
int m ;
int slove(double x)
{
int sum = 0 ;
double d = A[0] ;
d += 2 * x ;
int i = 0 ;
++ sum ;
while(d < A[m -1] * 1.0 )
{
while(A[i] <= d) ++ i ;
d = A[i] + 2 * x ;
sum ++ ;
}
return sum ;
}
double Find(double left , double right)
{
double mid ;
while(right - left > eps)
{
mid = left + (right - left) / 2 ;
if(slove(mid) <= n)
right = mid ;
else left = mid +eps ;
}
return left ;
}
int main()
{
int cas ;
double low ;
double high ;
double ans ;
while(scanf("%d",&cas) != EOF)
{
while(cas --)
{
scanf("%d%d",&n,&m) ;
for(int i = 0 ;i < m ; ++ i)
scanf("%d",&A[i]) ;
sort(A , A+ m) ;
low = 0 ;
high = A[m -1] * 1.0 / n ;
ans = Find(low , high) ;
printf("%.1lf\n",ans) ;
}
}
return 0 ;
}

60
HDOJ/2753_autoAC.cpp Normal file
View File

@ -0,0 +1,60 @@
#include <set>
#include <map>
#include <list>
#include <stack>
#include <cmath>
#include <vector>
#include <queue>
#include <string>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long LL;
const int INF = 0x3f3f3f3f;
const double eps = 1e-5;
int n,m;
int sum;
int Dp[110000];
int a[110];
int main()
{
int T;
while(~scanf("%d",&T))
{
while(T--)
{
scanf("%d %d",&m,&n);
sum=0;
for(int i=1;i<=n;i++)
{
scanf("%d",&a[i]);
sum=max(sum,a[i]);
}
sum+=m;
memset(Dp,INF,sizeof(Dp));
Dp[0]=0;
for(int i=1;i<=n;i++)
{
for(int j=sum;j>=a[i];j--)
{
if(Dp[j-a[i]]!=INF)
{
Dp[j]=min(Dp[j],Dp[j-a[i]]+1);
}
}
}
for(int i=m;;i++)
{
if(Dp[i]!=INF)
{
printf("%d %d\n",i,Dp[i]);
break;
}
}
}
}
return 0;
}

72
HDOJ/2754_autoAC.cpp Normal file
View File

@ -0,0 +1,72 @@
#include <cstdlib>
#include <cctype>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
#include <string>
#include <iostream>
#include <sstream>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <fstream>
#include <numeric>
#include <iomanip>
#include <bitset>
#include <list>
#include <stdexcept>
#include <functional>
#include <utility>
#include <ctime>
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
#define MAX(a,b) ((a) > (b) ? (a) : (b))
#define MIN(a,b) ((a) < (b) ? (a) : (b))
#define MEM(a,b) memset((a),(b),sizeof(a))
const int N = 10000;
vector<int> v[N + 1];
int flag[N + 1];
int cnt;
void dfs(int x)
{
if (flag[x]) return;
flag[x] = 1;
cnt++;
for (int i = 0; i < v[x].size(); i++)
{
dfs(v[x][i]);
}
}
int main()
{
int ncase;
while (cin >> ncase)
{
while (ncase--)
{
int n, m, l;
cin >> n >> m >> l;
for (int i = 1; i <= n; i++) v[i].clear();
for (int i = 0; i < m; i++)
{
int x, y;
cin >> x >> y;
v[x].push_back(y);
}
MEM(flag, 0);
cnt = 0;
while (l--)
{
int x;
cin >> x;
dfs(x);
}
cout << cnt << endl;
}
}
return 0;
}

135
HDOJ/2755_autoAC.cpp Normal file
View File

@ -0,0 +1,135 @@
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <cmath>
#include <cstring>
using namespace std;
#define PI 3.14159265358979
#define EPSILON 1e-6
typedef struct Point
{
double x,y;
Point(double a = 0,double b = 0):x(a),y(b) {}
Point(const Point & p):x(p.x),y(p.y) {}
friend Point operator + (const Point &p1, const Point & p2)
{
return Point(p1.x+p2.x,p1.y+p2.y);
}
Point & operator += (const Point & p)
{
x += p.x;
y += p.y;
return *this;
}
friend Point operator * (const Point & p, int u)
{
return Point(p.x*u,p.y*u);
}
Point & operator = (const Point & p)
{
x = p.x;
y = p.y;
return * this;
}
friend bool operator == (const Point & p1, const Point & p2)
{
if(fabs(p1.x-p2.x)<EPSILON && fabs(p1.y-p2.y)<EPSILON)
return true;
return false;
}
}Vector;
struct Logo
{
char str[6];
int u;
};
Logo ls[1000];
int num;
char cmd[6];
Point Test(double theta, Vector v,Point pt,int j,int degree)
{
if(cmd[0] == 'l')
{ theta+=degree; v = Vector(cos(PI*theta/180),sin(PI*theta/180));}
else
{ theta-=degree; v = Vector(cos(PI*theta/180),sin(PI*theta/180)); }
for(int k = j+1; k<num; k++)
{
int t = ls[k].u;
switch(ls[k].str[0])
{
case 'f': pt += v*t; break;
case 'b': pt += v*(-t); break;
case 'l': theta+=t; v = Vector(cos(PI*theta/180),sin(PI*theta/180));
break;
case 'r': theta-=t; v = Vector(cos(PI*theta/180),sin(PI*theta/180));
break;
}
}
return pt;
}
int main()
{
int test,i,j,k,t;
char unit[128];
while(scanf("%d",&test)==1)
{
for(i = 0; i<test; i++)
{
scanf("%d",&num);
Point pt;
Vector v(1,0);
Vector vx;
double theta = 0.0;
for(j = 0; j<num; j++)
{
scanf("%s %s",cmd,unit);
if(unit[0] == '?')
break;
t = atoi(unit);
switch(cmd[0])
{
case 'f': pt += v*t; break;
case 'b': pt += v*(-t); break;
case 'l': theta+=t; v = Vector(cos(PI*theta/180),sin(PI*theta/180));
break;
case 'r': theta-=t; v = Vector(cos(PI*theta/180),sin(PI*theta/180));
break;
}
}
for(k = j+1; k<num; k++)
{
scanf("%s %d",ls[k].str,&ls[k].u);
}
if(cmd[0] == 'l' || cmd[0] == 'r')
{
for(int degree = 0; degree < 360; degree++)
{
if(Test(theta,v,pt,j,degree) == Point(0.0,0.0) )
{
printf("%d\n",degree);
break;
}
}
}
else
{
vx = v;
for(k = j+1; k<num; k++)
{
t = ls[k].u;
switch(ls[k].str[0])
{
case 'f': pt += v*t; break;
case 'b': pt += v*(-t); break;
case 'l': theta+=t; v = Vector(cos(PI*theta/180),sin(PI*theta/180));
break;
case 'r': theta-=t; v = Vector(cos(PI*theta/180),sin(PI*theta/180));
break;
}
}
printf("%d\n",(int)(sqrt(pt.x*pt.x + pt.y*pt.y)+0.5));
}
}
}
return 0;
}

31
HDOJ/2756_autoAC.cpp Normal file
View File

@ -0,0 +1,31 @@
#include <cstdio>
#include <queue>
using namespace std;
bool vis[1000000];
int main(){
int T, n;
while (scanf("%d",&T)==1){
while (T--){
scanf("%d", &n);
int temp, ans = 0;
queue<int> que;
while (n--){
scanf("%d", &temp);
while (vis[temp]){
vis[que.front()] = false;
que.pop();
}
que.push(temp);
vis[temp] = true;
if (que.size() > ans)
ans = que.size();
}
printf("%d\n", ans);
while (que.size()){
vis[que.front()] = false;
que.pop();
}
}
}
return 0;
}

71
HDOJ/2757_autoAC.cpp Normal file
View File

@ -0,0 +1,71 @@
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
int sx,sy,ex,ey;
char a[1002][1002];
int b[1002][1002];
int dir[8][2]={0,-1,1,-1,1,0,1,1,0,1,-1,1,-1,0,-1,-1};
struct fuck{
int x, y,t;
friend bool operator< (const fuck &a, const fuck &b)
{
return a.t>b.t;
}
}f;
priority_queue<fuck> q;
int bfs()
{
int nx,ny,nt,x,y,t,i;
if(sx==ex&&sy==ey)
return 0;
f.x=sx;f.y=sy;f.t=0;
q.push(f);
b[sx][sy]=0;
while(!q.empty())
{
x=q.top().x;
y=q.top().y;
t=q.top().t;
q.pop();
for(i=0;i<8;i++)
{
nx=x+dir[i][1];
ny=y+dir[i][0];
nt=t+(i!=(a[x][y]-48));
if(a[nx][ny]!='x'&&nt<b[ex][ey]&&nt<b[nx][ny])
{
f.x=nx;f.y=ny;f.t=nt;
if(nx!=ex||ny!=ey)
q.push(f);
b[nx][ny]=nt;
}
}
}
return b[ex][ey];
}
int main()
{
int n,t,m,i,j;
memset(a,'x',sizeof(a));
while(scanf("%d%d",&n,&m)==2)
{
getchar();
for(i=1;i<=n;i++)
{
for(j=1;j<=m;j++)
scanf("%c",&a[i][j]);
getchar();
}
scanf("%d",&t);
while(t--)
{
scanf("%d%d%d%d",&sx,&sy,&ex,&ey);
for(i=1;i<=n;i++)
for(j=1;j<=m;j++)
b[i][j]=2002;
printf("%d\n",bfs());
}
}
return 0;
}

26
HDOJ/2760_autoAC.cpp Normal file
View File

@ -0,0 +1,26 @@
#include <cstdio>
#include <string>
#include <iostream>
using namespace std;
int T;
string str[105];
int l, n;
void work()
{
scanf("%d%d\n", &l, &n);
for (int i = 0; i < n; ++i) cin >> str[i];
str[n] = str[0];
int ans = n * l;
string cur = str[0];
for (int i = 1; i < n; ++i) {
int common = 0;
for (int cl = 1; cl <= l; ++cl) if (cur.substr(cur.size() - cl, cl) == str[i].substr(0, cl)) common = cl;
cur += str[i].substr(common);
}
printf("%d\n", cur.size());
}
int main()
{
while (scanf("%d", &T) != EOF)
while (T--) work();
}

62
HDOJ/2762_autoAC.cpp Normal file
View File

@ -0,0 +1,62 @@
#include <iostream>
using namespace std;
const int MAXP = 100;
int dis(int *p1, int *p2)
{
int d = 0;
for(int i = 0; i < 3; ++i)
{
d += abs(p1[i] - p2[i]);
}
return d;
}
int main()
{
int N;
cin>>N;
int points[MAXP][3];
for(int no = 0; no < N; ++no)
{
int P;
cin>>P;
fscanf(stdin, "%d,%d,%d", &points[0][0], &points[0][1], &points[0][2]);
int area = 6;
bool iscorrect = true;
cout<<no + 1<<" ";
for(int i = 1; i < P; ++i)
{
fscanf(stdin, "%d,%d,%d", &points[i][0], &points[i][1], &points[i][2]);
if(!iscorrect)
{
continue;
}
area += 6;
int j = 0;
bool isconnected = false;
while(j < i)
{
int d = dis(points[i], points[j]);
if(d == 0)
{
break;
}
if(d == 1)
{
isconnected = true;
area -= 2;
}
j++;
}
if(j != i || !isconnected)
{
iscorrect = false;
cout<<"NO "<<i + 1<<endl;
}
}
if(iscorrect)
{
cout<<area<<endl;
}
}
return 0;
}

121
HDOJ/2763_autoAC.cpp Normal file
View File

@ -0,0 +1,121 @@
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int N = 21;
const int M = 20;
int ans[21][N] = {{1}};
int BigNumPow(int x[], int n);
int BigNumCopy(int x[], int y[]);
int BigNumMul(int x[], int y[]);
int BigNumAdd(int x[], int y[]);
int main()
{
int n, t;
int i, j;
int BigNum[N], BigPow[N], BigStep[N], BigCycle[N], tem[N];
memset(BigNum, 0, sizeof(BigNum));
memset(BigPow, 0, sizeof(BigPow));
memset(BigStep, 0, sizeof(BigStep));
memset(BigCycle, 0, sizeof(BigCycle));
BigNum[0] = 2;
BigStep[0] = 6;
BigStep[1] = 1;
BigPow[0] = 1;
BigCycle[0] = 4;
for(i = 1; i < 20; ++i)
{
while(BigNum[i] == 0 || BigNum[i] > 2)
{
BigNumMul(BigNum, BigStep);
BigNumAdd(BigPow, BigCycle);
}
BigNumCopy(ans[i], BigPow);
BigNumPow(BigStep, 5);
memset(tem, 0, sizeof(tem));
for(j = 0; j < M; ++j)
{
tem[j] += BigCycle[j] * 5;
if(tem[j] > 9)
{
tem[j + 1] += tem[j] / 10;
tem[j] = tem[j] % 10;
}
}
BigNumCopy(BigCycle, tem);
}
scanf("%d", &t);
for(j = 1; j <= t; ++j)
{
scanf("%d", &n);
printf("%d %d ", j, n);
--n;
i = M;
while(ans[n][i] == 0)
--i;
while(i >= 0)
printf("%d", ans[n][i--]);
printf("\n");
}
return 0;
}
int BigNumPow(int x[], int n)
{
int tmp[N];
int res[N];
BigNumCopy(tmp, x);
memset(res, 0, sizeof(res));
res[0] = 1;
while(n > 0)
{
if(n & 1)
{
BigNumMul(res, tmp);
}
BigNumMul(tmp, tmp);
n = n >> 1;
}
BigNumCopy(x, res);
return 0;
}
int BigNumCopy(int x[], int y[])
{
int i;
for(i = 0; i < N; ++i)
x[i] = y[i];
return 0;
}
int BigNumMul(int x[], int y[])
{
int i, j, k;
int tem[N];
int res[N];
memset(res, 0, sizeof(res));
for(i = 0; i < M; ++i)
{
memset(tem, 0, sizeof(tem));
for(k = i, j = 0; k < M; ++j, ++k)
{
tem[k] += y[i] * x[j];
tem[k + 1] += tem[k] / 10;
tem[k] = tem[k] % 10;
}
BigNumAdd(res, tem);
}
BigNumCopy(x, res);
return 0;
}
int BigNumAdd(int x[], int y[])
{
int i;
for(i = 0; i < M; ++i)
{
x[i] += y[i];
if(x[i] > 9)
{
x[i] -= 10;
++x[i + 1];
}
}
return 0;
}

49
HDOJ/2765_autoAC.cpp Normal file
View File

@ -0,0 +1,49 @@
#include<iostream>
using namespace std;
const int MAX = 2140000000;
int f[1000001];
void dfs(int p)
{
int i,sum = 1,temp;
if(p%2 == 1)
{
for(i=1;i<p;i+=2)
{
temp = (p-i)/2;
if(f[temp]==MAX)
dfs(temp);
sum += f[temp];
}
}
else //even
{
for(i=0;i<p;i+=2)
{
temp = (p-i)/2;
if(f[temp]==MAX)
dfs(temp);
sum += f[temp];
}
}
f[p] = sum;
}
int main()
{
int t,n,i,temp;
for(i=0;i<=10000;i++)
f[i] = MAX;
f[0] = 0;
f[1] = 1;
f[2] = 2;
f[3] = 2;
int cas = 1;
cin>>t;
while(t--)
{
cin>>n;
if(f[n] == MAX)
dfs(n);
cout<<cas++<<" "<<f[n]<<endl;
}
return 0;
}

60
HDOJ/2766_autoAC.cpp Normal file
View File

@ -0,0 +1,60 @@
#include <cstdio>
#include <iostream>
#include <cstring>
#include <cassert>
#include <algorithm>
#include <map>
#include <string>
#include <vector>
using namespace std;
typedef __int64 ll;
typedef vector<int> vi;
typedef vector<ll> vll;
string buf;
vll weight;
int deal(){
weight.clear();
cin >> buf;
int depth = 0;
ll tmp;
for (string::iterator ii = buf.begin(); ii != buf.end(); ii++){
switch (*ii){
case '[':
{
depth++;
}break;
case ']':
{
depth--;
}break;
case ',':break;
default:
{
tmp = 0;
while ('0' <= *ii && *ii <= '9') tmp = tmp * 10 + *ii - '0', ii++;
ii--;
weight.push_back(tmp << depth);
}
}
}
sort(weight.begin(), weight.end());
int len = weight.size();
int best = 0, cur = 1;
weight.push_back(-1);
for (int i = 0; i < len; i++){
if (weight[i + 1] != weight[i]){
best = max(best, cur);
cur = 1;
}
else cur++;
}
return len - best;
}
int main(){
int T;
scanf("%d", &T);
while (T--){
cout << deal() << endl;
}
return 0;
}

112
HDOJ/2767_autoAC.cpp Normal file
View File

@ -0,0 +1,112 @@
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <stack>
using namespace std;
#define MAXN 200010
#define clr(x,k) memset((x),(k),sizeof(x))
struct node
{
int st,to,next;
}
edge[MAXN];
int n,m,ct,id;
int head[MAXN],low[MAXN],dfn[MAXN],belong[MAXN],in[MAXN],to[MAXN];
bool instack[MAXN];
stack<int>q;
void add_e(int i,int u,int v)
{
edge[i].st=u;
edge[i].to=v;
edge[i].next=head[u];
head[u]=i;
}
void tarjan(int i)
{
int j;
dfn[i]=low[i]=++id;
q.push(i);
instack[i]=1;
for(int u=head[i]; ~u; u=edge[u].next)
{
j=edge[u].to;
if(dfn[j]==0)
{
tarjan(j);
if(low[i]>low[j])
low[i]=low[j];
}
else if(instack[j]&&low[i]>low[j])
low[i]=dfn[j];
}
if(dfn[i]==low[i])
{
ct++;
do
{
j=q.top();
q.pop();
instack[j]=0;
belong[j]=ct;
}
while(i!=j);
}
}
int main()
{
int t,i,u,v,sum1,sum2;
cin>>t;
while(t--)
{
clr(head,-1);
clr(low,0);
clr(dfn,0);
clr(belong,0);
clr(in,0);
clr(to,0);
while(!q.empty())
q.pop();
cin>>n>>m;
for(i=0; i<m; i++)
{
cin>>u>>v;
add_e(i,u,v);
}
id=ct=0;
for(i=1; i<=n; i++)
{
if(!dfn[i])
tarjan(i);
}
if(ct==1)
{
cout<<0<<endl;
continue;
}
for(i=1; i<=ct; i++)
{
in[i]=to[i]=0;
}
for(i=0; i<m; i++)
{
if(belong[edge[i].st]!=belong[edge[i].to])
{
in[belong[edge[i].st]]++;
to[belong[edge[i].to]]++;
}
}
sum1=sum2=0;
for(i=1; i<=ct; i++)
{
if(in[i]==0)
sum1++;
if(to[i]==0)
sum2++;
}
cout<<max(sum1,sum2)<<endl;
}
return 0;
}

69
HDOJ/2768_autoAC.cpp Normal file
View File

@ -0,0 +1,69 @@
#include<stdio.h>
#include<string.h>
int tot,list[20005],mark_dfs[20005],mark_gx[20005],n,m,k;
struct dian
{
char need[50];
char no[50];
}cun1[20005];
struct ren
{
int date,next;
}cun[20005];
void add(int a,int b)
{
cun[tot].date=b;
cun[tot].next=list[a];
list[a]=tot++;
}
int dfs(int x)
{
for(int i=list[x];i;i=cun[i].next)
{
int date=cun[i].date;
if(mark_dfs[date]) continue;
mark_dfs[date]=1;
if(mark_gx[date]==-1||dfs(mark_gx[date]))
{
mark_gx[date]=x;
return 1;
}
}
return 0;
}
void clear()
{
memset(list,0,sizeof(list));
}
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
tot=1;
clear();
scanf("%d%d%d",&n,&m,&k);
for(int i=1;i<=k;i++)
{
scanf("%s%s",cun1[i].need,cun1[i].no);
}
for(int i=1;i<k;i++)
for(int j=i+1;j<=k;j++)
{
if((!strcmp(cun1[i].need,cun1[j].no)||!strcmp(cun1[i].no,cun1[j].need)))
{
add(i,j);
add(j,i);
}
}
memset(mark_gx,255,sizeof(mark_gx));
int sum=0;
for(int i=1;i<=k;i++)
{
memset(mark_dfs,0,sizeof(mark_dfs));
sum+=dfs(i);
}
printf("%d\n",k-sum/2);
}
}

64
HDOJ/2769_autoAC.cpp Normal file
View File

@ -0,0 +1,64 @@
#include <iostream>
#include <stdio.h>
#include<string.h>
#include<algorithm>
#include<string>
#include<ctype.h>
using namespace std;
#define mod 10001
long long in[10010];
long long out[10010];
long long exgcd(long long a,long long b,long long &x,long long &y)
{
if(!b)
{
x=1;
y=0;
return a;
}
long long tt=exgcd(b,a%b,x,y);
long long t;
t=x;
x=y;
y=(t-a/b*y);
return tt;
}
int main()
{
int n;
scanf("%d",&n);
for(int i=0;i<n;i++)
scanf("%I64d",in+i);
int ok=0;
for(long long i=0;i<=10000;i++)
{
long long c=((in[1]-i*i*in[0]%10001)%10001+10001)%10001;
long long a=i+1;
long long b=-10001;
long long x,y;
long long d=exgcd(a,b,x,y);
if(c%d)
continue;
long long t=abs(b/d);
x*=c/d;
x=(x%t+t)%t;
for(int j=0;j<n;j++)
{
out[j]=(i*in[j]+x)%10001;
if(j==n-1)
{
ok=1;
break;
}
if(((i*out[j]+x)%10001)!=in[j+1])
break;
}
if(ok)
break;
}
for(int i=0;i<n;i++)
{
printf("%I64d\n",out[i]);
}
return 0;
}

66
HDOJ/2770_autoAC.cpp Normal file
View File

@ -0,0 +1,66 @@
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const long long inf=1LL<<62;
const int maxn=110;
const int maxm=maxn*maxn*2;
int n,cnt;
long long h[maxn],s[maxm],dp[maxn][maxm],d;
int q[maxm];
void Init()
{
for(int i=0;i<=n;i++)
for(int j=0;j<cnt;j++)
dp[i][j]=inf;
}
void solve()
{
Init();
int ind=lower_bound(s,s+cnt,h[1])-s;
dp[1][ind]=0;
for(int i=2;i<=n;i++)
{
int pre=0,last=0,now=0;
for(int j=0;j<cnt;j++)
{
while(now<cnt&&s[now]<=s[j]+d)
{
while(pre<last&&dp[i-1][q[last-1]]>=dp[i-1][now])
last--;
q[last++]=now++;
}
while(pre<last&&s[j]-d>s[q[pre]])
pre++;
dp[i][j]=abs(h[i]-s[j])+dp[i-1][q[pre]];
}
}
ind=lower_bound(s,s+cnt,h[n])-s;
if(dp[n][ind]>=inf)
printf("impossible\n");
else
printf("%I64d\n",dp[n][ind]);
}
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
cnt=0;
scanf("%d%I64d",&n,&d);
for(int i=1;i<=n;i++)
scanf("%I64d",&h[i]);
for(int i=1;i<=n;i++)
for(long long j=0;j<n;j++)
{
s[cnt++]=h[i]-j*d;
s[cnt++]=h[i]+j*d;
}
sort(s,s+cnt);
cnt=unique(s,s+cnt)-s;
solve();
}
return 0;
}

116
HDOJ/2771_autoAC.cpp Normal file
View File

@ -0,0 +1,116 @@
#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
using namespace std;
const int maxn = 50 + 5;
const int maxc = 1000 + 1;
int n;
int x0[maxn], y0[maxn], z0[maxn], x1[maxn], y1[maxn], z1[maxn];
int xs[maxn*2], ys[maxn*2], zs[maxn*2], nx, ny, nz;
int color[maxn*2][maxn*2][maxn*2];
int dx[] = {0, 0, 0, 0, -1, 1};
int dy[] = {0, 0, -1, 1, 0, 0};
int dz[] = {-1, 1, 0, 0, 0, 0};
struct Cell
{
int x, y, z;
Cell(int x = 0, int y = 0, int z = 0) : x(x), y(y), z(z) {}
void setVis() const {
color[x][y][z] = 2;
}
int volume() const {
return (xs[x+1]-xs[x])*(ys[y+1]-ys[y])*(zs[z+1]-zs[z]);
}
Cell neighbor(int i) const {
return Cell(x+dx[i], y+dy[i], z+dz[i]);
}
bool valid() const {
return x>=0 && x<nx-1 && y>=0 && y<ny-1 && z>=0 && z<nz-1;
}
bool solid() const {
return color[x][y][z] == 1;
}
int area(int i) const {
if (dx[i] != 0) return (ys[y+1]-ys[y])*(zs[z+1]-zs[z]);
else if(dy[i] != 0) return (xs[x+1]-xs[x])*(zs[z+1]-zs[z]);
else return (xs[x+1]-xs[x])*(ys[y+1]-ys[y]);
}
bool getVis() const {
return color[x][y][z] == 2;
}
};
void discretize(int* x, int& n)
{
sort(x, x + n);
n = (int)(unique(x, x+n) - x);
}
int ID(int* x, int n, int x0)
{
return (int)(lower_bound(x, x+n, x0) - x);
}
void floodfill(int& s, int& v)
{
s = v = 0;
Cell c; c.setVis();
queue<Cell> Q; Q.push(c);
while (!Q.empty())
{
Cell now = Q.front(); Q.pop();
v += now.volume();
for (int i = 0; i < 6; i++)
{
Cell nxt = now.neighbor(i);
if (!nxt.valid()) continue;
if (nxt.solid()) s += now.area(i);
else if(!nxt.getVis())
{
nxt.setVis();
Q.push(nxt);
}
}
}
v = maxc*maxc*maxc - v;
}
int main()
{
int t; scanf("%d", &t);
while (t--)
{
scanf("%d", &n);
nx = ny = nz = 2;
xs[0] = ys[0] = zs[0] = 0;
xs[1] = ys[1] = zs[1] = maxc;
for (int i = 0; i < n; i++)
{
scanf("%d%d%d", &x0[i], &y0[i], &z0[i]);
scanf("%d%d%d", &x1[i], &y1[i], &z1[i]);
x1[i] += x0[i], y1[i] += y0[i], z1[i] += z0[i];
xs[nx++] = x0[i], xs[nx++] = x1[i];
ys[ny++] = y0[i], ys[ny++] = y1[i];
zs[nz++] = z0[i], zs[nz++] = z1[i];
}
discretize(xs, nx), discretize(ys, ny), discretize(zs, nz);
memset(color, 0, sizeof(color));
for (int i = 0; i < n; i++)
{
int X1 = ID(xs, nx, x0[i]), X2 = ID(xs, nx, x1[i]);
int Y1 = ID(ys, ny, y0[i]), Y2 = ID(ys, ny, y1[i]);
int Z1 = ID(zs, nz, z0[i]), Z2 = ID(zs, nz, z1[i]);
for (int X = X1; X < X2; X++)
{
for (int Y = Y1; Y < Y2; Y++)
{
for (int Z = Z1; Z < Z2; Z++)
{
color[X][Y][Z] = 1;
}
}
}
}
int s, v;
floodfill(s, v);
printf("%d %d\n", s, v);
}
return 0;
}

71
HDOJ/2772_autoAC.cpp Normal file
View File

@ -0,0 +1,71 @@
#include <iostream>
int main()
{
int t,n,min,max_1,max_2,min_1,min_2;
scanf("%d",&t);
while(t--)
{
scanf("%d",&n);
if(n<=1)
return 0;
else if(n==2)
printf("1 1\n");
else if(n==3)
printf("7 7\n");
else if(n==4)
printf("4 11\n");
else if(n==5)
printf("2 71\n");
else if(n==6)
printf("6 111\n");
else if(n==7)
printf("8 711\n");
else if(n==8)
printf("10 1111\n");
else if(n==9)
printf("18 7111\n");
else if(n==10)
printf("22 11111\n");
else if(n==11)
printf("20 71111\n");
else if(n==12)
printf("28 111111\n");
else if(n==13)
printf("68 711111\n");
else if(n==14)
printf("88 1111111\n");
else
{
max_1=(n-15)/7;
max_2=(n-14)%7;
if(max_2==1)
printf("108");
else if(max_2==2)
printf("188");
else if(max_2==3)
printf("200");
else if(max_2==4)
printf("208");
else if(max_2==5)
printf("288");
else if(max_2==6)
printf("688");
else if(max_2==0)
printf("888");
if(max_1)
while(max_1--)
printf("8");
printf(" ");
min_1=n/2-1;
min_2=n%2;;
if(min_2==0)
printf("1");
else if(min_2==1)
printf("7");
while(min_1--)
printf("1");
printf("\n");
}
}
return 0;
}

88
HDOJ/2773_autoAC.cpp Normal file
View File

@ -0,0 +1,88 @@
#include<stdio.h>
#include<cmath>
#include<algorithm>
#include<string.h>
#include<iostream>
#define eps 1e-8
#define N 20010
using namespace std;
int Sig(double a)
{
return a<-eps?-1:a>eps;
}
struct Point
{
double x,y;
void input()
{
scanf("%lf%lf",&x,&y);
}
Point(){}
Point(double x0,double y0):x(x0),y(y0){}
};
int n1,n2;
Point p1[110];
Point p2[110];
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 sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.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;
}
void Judge(Point o,Point a,Point b,double &d)
{
Point tmp=Point(b.y-a.y+o.x,a.x-b.x+o.y);
Point p=Intersection(o,tmp,a,b);
if(Sig(Dis(a,b)-Dis(a,p)-Dis(b,p)))
d=min(Dis(a,o),Dis(b,o));
else
d=fabs(Xmult(o,a,b))/Dis(a,b);
}
int main()
{
int t;
scanf("%d",&t);
while(t--)
{
scanf("%d",&n1);
for(int i=0;i<n1;i++)
p1[i].input();
p1[n1]=p1[0];
scanf("%d",&n2);
for(int i=0;i<n2;i++)
p2[i].input();
p2[n2]=p2[0];
double s1=999999999;
double s2=999999999;
double l;
for(int i=0;i<n1;i++)
{
for(int j=0;j<n2;j++)
{
Judge(p1[i],p2[j],p2[j+1],l);
s1=min(s1,l);
}
}
for(int i=0;i<n2;i++)
{
for(int j=0;j<n1;j++)
{
Judge(p2[i],p1[j],p1[j+1],l);
s2=min(s2,l);
}
}
printf("%.8f\n",min(s1,s2)*0.5);
}
return 0;
}

165
HDOJ/2775_autoAC.cpp Normal file
View File

@ -0,0 +1,165 @@
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
using namespace std;
int v[10],n,a[8][2],rest[20],now[8],occ[23],tot[100];
long long score[100];
char s[21];
int getrank(char ch){
if(ch=='A')return 1;
if(ch=='T')return 10;
if(ch=='J')return 11;
if(ch=='Q')return 12;
if(ch=='K')return 13;
return ch-'2'+2;
}
int getsuit(char ch){
if(ch=='c')return 1;
if(ch=='d')return 2;
if(ch=='h')return 3;
if(ch=='s')return 4;
}
bool can(int col,int mask)
{
for(int i=0;i<5;++i)
for(int j=i+1;j<5;++j)
if(now[i]==now[j])
return false;
for(int i=0;i<5;++i)
if((mask&(1<<i))==0)
{
if(a[i][1]!=col)return false;
}
else
{
for(int j=0;j<5;++j)
if(a[j][0]==now[i]&&a[j][1]==col)
return false;
}
return true;
}
bool is0()
{
for(int i=1;i<=14;++i)
if(occ[i]==2)
return 1;
return 0;
}
bool is1()
{
int ret=0;
for(int i=1;i<=14;++i)
if(occ[i]==2)
++ret;
return ret==2;
}
bool is2()
{
for(int i=1;i<=14;++i)
if(occ[i]==3)
return 1;
return 0;
}
bool is3()
{
if(occ[1]&&occ[10]&&occ[11]&&occ[12]&&occ[13])
return true;
for(int i=1;i+5-1<=13;++i)
if(occ[i]&&occ[i+1]&&occ[i+2]&&occ[i+3]&&occ[i+4])
return true;
return false;
}
bool is5()
{
for(int i=1;i<=14;++i)
if (occ[i] == 3)
for(int j=1;j<=14;++j)
if(occ[j]==2)
return true;
return false;
}
bool is6()
{
for(int i=1;i<=14;++i)
if(occ[i]==4)
return 1;
return 0;
}
int getscore()
{
if(is6())return v[6];
if(is5())return v[5];
if(is3())return v[3];
if(is2())return v[2];
if(is1())return v[1];
if(is0())return v[0];
return 0;
}
int getsame(int *r)
{
if(occ[1]&&occ[10]&&occ[11]&&occ[12]&&occ[13])
return 8;
for(int i=1;i+5-1<=13;++i)
if(occ[i]&&occ[i+1]&&occ[i+2]&&occ[i+3]&&occ[i+4])
return 7;
return 4;
}
void search(int u,int cnt, int mask)
{
if(u==5)
{
memset(occ,0,sizeof(occ));
for(int i=0;i<5;++i)
++occ[now[i]];
tot[mask] += cnt;
int tmp = 0;
for(int i=1;i<=4;++i)
if(can(i,mask)) {
++ tmp;
}
if (is6() || is5()) tmp = 0;
if (tmp) score[mask] += (long long)tmp * (long long)v[getsame(now)];
score[mask]+=(long long)(cnt - tmp)*(long long)getscore();
return;
}
now[u]=a[u][0];
search(u + 1, cnt , mask);
for(int i=1;i<=13;++i)
if(rest[i])
{
--rest[i];
now[u]=i;
search(u+1,cnt*(rest[i]+1),mask|(1<<u));
++rest[i];
}
}
int main()
{
int _;
for(scanf("%d",&_);_--;)
{
for(int i=0;i<9;++i)scanf("%d",v+i);
scanf("%d%*c",&n);
for (int k = 0; k < n; ++ k) {
for(int i=1;i<=13;++i)rest[i]=4;
for(int i=0;i<5;++i)
{
scanf("%s",s);
a[i][0]=getrank(s[0]);
--rest[a[i][0]];
a[i][1]=getsuit(s[1]);
}
memset(tot, 0, sizeof(tot));
memset(score, 0, sizeof(score));
search(0,1,0);
double ans = 0.;
for (int i = 0; i < (1<<5); ++ i)
if (tot[i]) {
ans = max(ans, (double)score[i] / (double)tot[i]);
}
printf("%.8f\n",ans);
}
}
return 0;
}

51
HDOJ/2779_autoAC.cpp Normal file
View File

@ -0,0 +1,51 @@
#include<iostream>
#include<algorithm>
#include<functional>
#include<queue>
using namespace std;
bool flag[50];
struct time
{
int start;
int end;
bool operator <(const time a)const
{
if(a.end==end)
return a.start<start;
return a.end<end;
}
}now,temp;
int main()
{
priority_queue<time>Q;
int i,n,j=0,t;
while(++j)
{
memset(flag,false,sizeof(flag));
scanf("%d",&n);
if(!n)
return 0;
for(i=0;i<n;i++)
{
scanf("%d%d",&now.start,&now.end);
now.start*=2,now.end*=2;
Q.push(now);
}
now.start=now.end=8*2;
int count=0;
while(!Q.empty())
{
temp=Q.top();
Q.pop();
for(t=temp.start;t<=temp.end-1;t++)
if(flag[t]==false)
{
now.start=max(t,now.start+1);
flag[t]=true;
count++;
break;
}
}
printf("On day %d Emma can attend as many as %d parties.\n",j,count);
}
}

131
HDOJ/2780_autoAC.cpp Normal file
View File

@ -0,0 +1,131 @@
#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<string>
#include<algorithm>
#include<memory.h>
#include<queue>
using namespace std;
int cnt,mark;
char vis[12][12];
int map[12][12];
struct Node
{
int x,y;
}node[102];
int Judge(int x,int y,int z)
{
int i,j,n,m;
for(i=0;i<9;i++)
{
if(map[i][y]==z && i!=x)
return 1;
}
for(j=0;j<9;j++)
{
if(map[x][j]==z && j!=y)
return 1;
}
for(n=0,i=x/3*3;n<3;n++,i++)
for(m=0,j=y/3*3;m<3;m++,j++)
{
if(i==x && j==y)
continue;
if(map[i][j]==z)
return 1;
}
return 0;
}
int judge()
{
int i,j;
for(i=0;i<9;i++)
for(j=0;j<9;j++)
{
if(!map[i][j])
continue;
if(Judge(i,j,map[i][j]))
return 1;
}
return 0;
}
void dfs(int n)
{
int i;
if(n==cnt)
{
mark=1;
return;
}
if(mark)
return;
for(i=1;i<=9;i++)
{
if(Judge(node[n].x,node[n].y,i))
continue;
map[node[n].x][node[n].y]=i;
dfs(n+1);
if(mark)
return;
map[node[n].x][node[n].y]=0;
}
}
void clear()
{
cnt=0;
memset(map,0,sizeof(map));
memset(vis,0,sizeof(vis));
memset(node,0,sizeof(node));
}
int main()
{
int k,i,j;
bool f=false;
scanf("%d",&k);
while(k--)
{
if(f)
printf("\n");
f=true;
clear();
for(i=0;i<9;i++)
{
scanf("%s",vis[i]);
}
for(i=0;i<9;i++)
{
for(j=0;j<9;j++)
{
map[i][j]=vis[i][j]-'0';
if(!map[i][j])
{
node[cnt].x=i;
node[cnt].y=j;
cnt++;
}
}
}
if(judge())
{
printf("Could not complete this grid.\n");
continue;
}
mark=0;
dfs(0);
if(mark)
{
for(i=0;i<9;i++)
{
for(j=0;j<9;j++)
printf("%d",map[i][j]);
printf("\n");
}
}
else
{
printf("Could not complete this grid.\n");
}
}
return 0;
}

116
HDOJ/2782_autoAC.cpp Normal file
View File

@ -0,0 +1,116 @@
#include <cstring>
#include <cstdio>
using namespace std;
int map[700][700];
int vis[700][700];
int ansx,ansy;
int ansd,anssum;
int n,m;
int res=0;
int xx[4]={0,-1,1,0};
int yy[4]={1,0,0,-1};
void dfs(int x,int y,int ans,int pre)
{
if(pre==-1)
{
int i;
for(i=0;i<4;i++)
{
int nx=x+xx[i];
int ny=y+yy[i];
if(nx<0||nx>=n||ny<0||ny>=m)
continue;
if(vis[nx][ny])
continue;
vis[nx][ny]=1;
dfs(nx,ny,ans+1,i);
vis[nx][ny]=0;
if(res>anssum)
{
ansx=x;
ansy=y;
ansd=i;
anssum=res;
}
}
return ;
}
int i;
int flag=1;
int nx=x+xx[pre];
int ny=y+yy[pre];
if(nx>=0&&nx<n&&ny>=0&&ny<m&&!vis[nx][ny])
{
vis[nx][ny]=1;
dfs(nx,ny,ans+1,pre);
vis[nx][ny]=0;
flag=0;
}
else
{
for(i=0;i<4;i++)
{
if(i==pre)
continue;
nx=x+xx[i];
ny=y+yy[i];
if(nx<0||nx>=n||ny<0||ny>=m)
continue;
if(vis[nx][ny])
continue;
vis[nx][ny]=1;
dfs(nx,ny,ans+1,i);
vis[nx][ny]=0;
flag=0;
}
}
if(flag)
{
if(res<ans)
res=ans;
}
}
int main()
{
int cas=0;
while(scanf("%d%d",&n,&m)!=EOF)
{
cas++;
if(n==0&&m==0)
break;
int r;
scanf("%d",&r);
int i;
memset(vis,0,sizeof(vis));
for(i=0;i<r;i++)
{
int x,y;
scanf("%d%d",&x,&y);
vis[x][y]=1;
}
int j;
anssum=-1;
res=0;
for(i=0;i<n;i++)
{
for(j=0;j<m;j++)
{
if(!vis[i][j])
{
vis[i][j]=1;
dfs(i,j,1,-1);
vis[i][j]=0;
}
}
}
printf("Case %d: %d %d %d ",cas,anssum,ansx,ansy);
if(ansd==0)
printf("E\n");
else if(ansd==1)
printf("N\n");
else if(ansd==2)
printf("S\n");
else if(ansd==3)
printf("W\n");
}
}

125
HDOJ/2783_autoAC.cpp Normal file
View File

@ -0,0 +1,125 @@
#include <cstdio>
#include <cstring>
#include <queue>
#include <iostream>
#include <map>
#include <stack>
using namespace std ;
typedef pair<int,int> pii ;
#define X first
#define Y second
const int N = 1010 ;
const int inf = 1e9+7 ;
typedef long long LL;
int n , xx[N] , pre[N] , ww[N] , tot ;
vector<pii>g[N];
struct node {
int a , c , d , id ;
node(){};
node( int a , int c , int d , int id ):a(a),c(c),d(d),id(id){}
bool operator < ( const node &A ) const {
if( d != A.d ) return d > A.d ;
else if( c != A.c ) return c > A.c ;
else {
stack<int>s1 , s2; int id1 = id , id2 = A.id ;
while( id1 != -1 ) { s1.push( xx[id1] ); id1 = pre[id1] ; }
while( id2 != -1 ) { s2.push( xx[id2] ); id2 = pre[id2] ; }
while( !s1.empty() ) {
int a = s1.top() ; s1.pop() ;
int b = s2.top() ; s2.pop() ;
if( a > b ) return true ;
}
return false ;
}
}
};
int bestpath[N] , bestcnt , bestcost ;
int tmppath[N] , tmpcnt , tmpcost ;
void Choose_best( int id , int cnt ) {
if( tmpcost > bestcost ) return ;
stack<int>s ;
while( id != -1 ) { s.push( xx[id] ); id = pre[id] ; }
tmpcnt = 0 ;
while( !s.empty() ) { tmppath[tmpcnt++] = s.top() ; s.pop() ; }
if( tmpcost < bestcost ) {
bestcnt = tmpcnt ;
bestcost = tmpcost ;
for( int i = 0 ; i < tmpcnt ; ++i ) bestpath[i] = tmppath[i] ;
return ;
}
if( cnt > bestcnt ) return ;
else if( cnt < bestcnt ) {
bestcnt = tmpcnt ;
for( int i = 0 ; i < tmpcnt ; ++i ) bestpath[i] = tmppath[i] ;
} else {
for( int i = 0 ; i < tmpcnt ; ++i ) {
if( bestpath[i] > tmppath[i] ) {
for( int j = i ; j < bestcnt ; ++j ) {
bestpath[j] = tmppath[j] ;
}
} else if ( bestpath[i] < tmppath[i] ) {
break ;
}
}
}
}
int dis[N] ;
void dij() {
memset( dis , 0x3f , sizeof dis );
priority_queue<node>que;
tot = 0 ; xx[tot] = 0 , pre[tot] = -1 ; tot++ ;
que.push( node(0,0,0,tot-1) );
dis[0] = 0 ;
while( !que.empty() ) {
int u = que.top().a , cnt = que.top().c , cost = que.top().d , id = que.top().id ;
que.pop();
if( cost > dis[u] ) continue ;
if( u == 1 ) {
if( dis[u] ) {
tmpcost = dis[u] ;
Choose_best( id , cnt );
}
return ;
}
for( int i = 0 ; i < g[u].size() ; ++i ) {
int v = g[u][i].X , w = ww[g[u][i].Y] ;
if( dis[v] > dis[u] + w ) {
dis[v] = dis[u] + w ;
xx[tot] = v ; pre[tot] = id ; tot++;
que.push( node( v , cnt+1 , dis[v] , tot - 1 ) ) ;
}
}
}
}
void Gao() {
dij();
for( int i = 0 ; i < n ; ++i ) {
int cc = ww[i] ; ww[i] = 0 ;
dij();
for( int j = i + 1 ; j < n ; ++j ) {
int dd = ww[j] ; ww[j] = 0 ;
dij(); ww[j] = dd ;
}
ww[i] = cc ;
}
for( int i = 0 ; i < bestcnt ; ++i ) cout << bestpath[i] << ' ' ;
cout << bestcost << endl ;
}
int Run() {
while( cin >> n && n ) {
bestcost = bestcnt = inf ;
for( int i = 0 ; i < N ; ++i ) g[i].clear();
for( int i = 0 ; i < n ; ++i ) {
int u , v , w ; cin >> u >> v >> w ;
ww[i] = w ;
g[u].push_back(pii(v,i));
g[v].push_back(pii(u,i));
}
Gao();
}
return 0 ;
}
int main() {
ios::sync_with_stdio(0);
return Run();
}

128
HDOJ/2785_autoAC.cpp Normal file
View File

@ -0,0 +1,128 @@
#include<cstdio>
#include<cstring>
#include<math.h>
#include<iostream>
using namespace std;
int n;
struct acc{
int meb;
int bam;
double mo;
}arr[110];
int judge(int ac, int b){
int i;
for(i = 0; i < n; i++)
{
if(arr[i].meb == ac && arr[i].bam == b)
{
return i;
}
}
return -1;
}
int main()
{
int i;
char cao[100];
while(cin >> n)
{
if(n == 0)
{
cout << "goodbye" << endl;
break;
}
char s;
for(i = 0; i < n; i++)
{
scanf("%d%c%d%lf", &arr[i].meb, &s, &arr[i].bam, &arr[i].mo);
}
while(1){
scanf("%s", cao);
int l = strlen(cao);
if(strcmp(cao, "end") == 0)
break;
int ac, bank;
double money;
if(cao[0] == 'c')
{
scanf("%d%c%d", &ac, &s, &bank);
if(judge(ac, bank) == -1)
{
arr[n].meb = ac;
arr[n].bam = bank;
arr[n++].mo = 0.0;
cout << "create: ok" << endl;
}
else
{
cout << "create: already exists" << endl;
}
}
else if(cao[0] == 'd')
{
scanf("%d%c%d%lf", &ac, &s, &bank, &money);
int num = judge(ac, bank);
if(num == -1)
{
printf("deposit %.2lf: no such account\n", money);
}
else{
arr[num].mo += money;
printf("deposit %.2lf: ok\n", money);
}
}
else if(cao[0] == 'w')
{
scanf("%d%c%d%lf", &ac, &s, &bank, &money);
int num = judge(ac, bank);
if(num == -1){
printf("withdraw %.2lf: no such account\n", money);
}
else{
if(arr[num].mo < money)
{
printf("withdraw %.2lf: insufficient funds\n", money);
}
else{
arr[num].mo -= money;
printf("withdraw %.2lf: ok\n", money);
}
}
}
else if(cao[0] == 't')
{
int ac1, bank1;
char s1;
scanf("%d%c%d%d%c%d%lf", &ac, &s, &bank, &ac1, &s1, &bank1, &money);
int num = judge(ac, bank);
int num1 = judge(ac1, bank1);
if(num == -1 || num1 == -1){
printf("transfer %.2lf: no such account\n", money);
}
else{
if(arr[num].meb == arr[num1].meb && arr[num].bam == arr[num1].bam)
{
printf("transfer %.2lf: same account\n", money);
}
else if(arr[num].mo < money)
{
printf("transfer %.2lf: insufficient funds\n", money);
}
else{
arr[num].mo -= money;
arr[num1].mo += money;
if(arr[num].bam == arr[num1].bam)
{
printf("transfer %.2lf: ok\n", money);
}
else{
printf("transfer %.2lf: interbank\n", money);
}
}
}
}
}
cout << "end" << endl << endl;
}
return 0;
}

57
HDOJ/2788_autoAC.cpp Normal file
View File

@ -0,0 +1,57 @@
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAX = 1010;
struct BID{
char name[25], type[5];
double price;
};
BID bid[MAX], buy[MAX], sell[MAX];
int main(){
int N, flag;
char issuer[12];
while(scanf("%d%s", &N, issuer) != EOF && N)
{
int cntb = 0, cnts = 0;
for(int i = 0; i < N; ++i)
{
scanf("%s%s%lf", bid[i].name, bid[i].type, &bid[i].price);
if(strcmp(bid[i].type, "buy") == 0)
buy[cntb++] = bid[i];
if(strcmp(bid[i].type, "sell") == 0)
sell[cnts++] = bid[i];
}
printf("%s\n", issuer);
for(int i = 0; i < N; ++i)
{
flag = 0; printf("%s:", bid[i].name);
if(strcmp(bid[i].type, "buy") == 0)
{
for(int j = 0; j < cnts; ++j)
{
if(sell[j].price <= bid[i].price)
{
printf(" %s", sell[j].name);
flag = 1;
}
}
}
if(strcmp(bid[i].type, "sell") == 0)
{
for(int j = 0; j < cntb; ++j)
{
if(buy[j].price >= bid[i].price)
{
printf(" %s", buy[j].name);
flag = 1;
}
}
}
if(!flag)
printf(" NO-ONE");
printf("\n");
}
}
return 0;
}

24
HDOJ/2791_autoAC.cpp Normal file
View File

@ -0,0 +1,24 @@
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 50009;
int a[N];
int main(){
int n, i, j, k;
while(~scanf("%d", &n) && n)
{
for(i = 0; i < n; ++i)
scanf("%d", &a[i]);
sort(a, a+n);
printf("%d-A", a[0]);
for(i = n-1; i >= 1; --i){
if(i&1)
printf(" %d-B", a[i]);
else
printf(" %d-A",a[i]);
}
puts("");
}
return 0;
}

64
HDOJ/2793_autoAC.cpp Normal file
View File

@ -0,0 +1,64 @@
#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
const __int64 MAX_N = 5;
const __int64 MOD = 1000000007;
__int64 N;
void multipy( __int64 a[MAX_N][MAX_N], __int64 b[MAX_N][MAX_N], __int64 c[MAX_N][MAX_N] ){
for( __int64 i = 1; i <= 4; i++ ){
for( __int64 j = 1; j <= 4; j++ ){
c[i][j] = 0;
for( __int64 k = 1; k <= 4; k++ ){
c[i][j] = ( c[i][j] + a[i][k] * b[k][j] % MOD ) % MOD;
}
}
}
}
void get_matrix_pow( __int64 a[MAX_N][MAX_N], __int64 n ){
__int64 ans[MAX_N][MAX_N] = {0};
__int64 temp[MAX_N][MAX_N];
for( __int64 i = 1; i <= 4; i++ ) ans[i][i] = 1;
while( n ){
if( n % 2 == 1 ){
multipy( ans, a, temp );
memcpy( ans, temp, sizeof( __int64 ) * MAX_N * MAX_ );
}
multipy( a, a, temp );
memcpy( a, temp, sizeof( __int64 ) * MAX_N * MAX_ );
n /= 2;
}
memcpy( a, ans, sizeof( __int64 ) * MAX_N * MAX_ );
}
__int64 solve( __int64 n ){
__int64 a[MAX_N][MAX_N] = {0};
if( n < 0 ){
return 0;
}
if( n == 0 ){
return 1;
}else if( n == 1 ){
return 2;
}
a[1][1] = 0;a[1][2] = 1;a[1][3] = 0;a[1][4] = 0;
a[2][1] = 0;a[2][2] = 0;a[2][3] = 1;a[2][4] = 0;
a[3][1] = 1;a[3][2] = 1;a[3][3] = 1;a[3][4] = 0;
a[4][1] = 0;a[4][2] = 0;a[4][3] = 1;a[4][4] = 1;
get_matrix_pow( a, n - 1 );
__int64 ans = 0;
__int64 b[MAX_N];
b[1] = b[2] = b[3] = 1;
b[4] = 2;
for( __int64 i = 1; i <= 4; i++ ){
ans = ( ans + a[4][i] * b[i] % MOD ) % MOD;
}
return ans;
}
int main(){
__int64 A, B;
while( scanf( "%I64d%I64d", &A, &B ) != EOF ){
printf( "%I64d\n", ( solve( B ) - solve( A - 1 ) + MOD ) % MOD );
}
return 0;
}

50
HDOJ/2795_autoAC.cpp Normal file
View File

@ -0,0 +1,50 @@
#include <iostream>
#include <algorithm>
#define MAXN 200050
#define lchild rt << 1, l, m
#define rchild rt << 1 | 1, m + 1, r
using namespace std;
int h, w, n, m;
class Segment_Tree{
private:
int node[MAXN << 2];
void push_up(int rt){
node[rt] = min(node[rt << 1], node[rt << 1 | 1]);
}
public:
void build(){
memset(node, 0, sizeof(node));
}
int update(int val, int rt = 1, int l = 1, int r = n){
if (l == r){
if (node[rt] + val <= w){
node[rt] += val;
return l;
}
else return 0;
}
int m = (l + r) >> 1, ret = 0;
if (node[rt << 1] + val <= w) ret += update(val, lchild);
else ret += update(val, rchild);
push_up(rt);
return ret;
}
int query(){
return node[1];
}
}st;
int main(){
int wi;
while (scanf("%d %d %d", &h, &w, &m) != EOF){
st.build();
n = min(h, m);
while (m--){
scanf("%d", &wi);
if (st.query() + wi <= w){
printf("%d\n", st.update(wi));
}
else printf("-1\n");
}
}
return 0;
}

28
HDOJ/2796_autoAC.cpp Normal file
View File

@ -0,0 +1,28 @@
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
int a[100],n;
int main(){
while(scanf("%d",&n)!=EOF){
memset(a,0,sizeof(a));
for(int i=1;i<=n;i++){
scanf("%d",&a[i]);
}
sort(a,a+n+1);
int k=1;
int fro=a[1];
int site=1;
int left=0;
for(int i=2;i<=n;i++){
if(a[i]>fro&&i-site+left>=k+1&&a[i]!=a[i-1]){
fro=a[i];
left=i-site-k-1+left;
site=i;
k++;
}else continue;
}
printf("%d\n",k);
}
return 0;
}