From 2d9cf4fdf2efddb4db5f4c1ac444a39dcfab30fb Mon Sep 17 00:00:00 2001 From: KiritoTRw <3021577574@qq.com> Date: Mon, 15 Aug 2016 09:13:31 +0800 Subject: [PATCH] Powered By HC TECH : AutoACer Engine 1600-1699 --- HDOJ/1603_autoAC.cpp | 168 ++++++++++++++++++++++++++++ HDOJ/1606_autoAC.cpp | 69 ++++++++++++ HDOJ/1608_autoAC.cpp | 106 ++++++++++++++++++ HDOJ/1609_autoAC.cpp | 87 +++++++++++++++ HDOJ/1611_autoAC.cpp | 44 ++++++++ HDOJ/1613_autoAC.cpp | 32 ++++++ HDOJ/1614_autoAC.cpp | 71 ++++++++++++ HDOJ/1615_autoAC.cpp | 29 +++++ HDOJ/1616_autoAC.cpp | 104 +++++++++++++++++ HDOJ/1617_autoAC.cpp | 62 +++++++++++ HDOJ/1619_autoAC.cpp | 69 ++++++++++++ HDOJ/1620_autoAC.cpp | 75 +++++++++++++ HDOJ/1621_autoAC.cpp | 34 ++++++ HDOJ/1622_autoAC.cpp | 88 +++++++++++++++ HDOJ/1623_autoAC.cpp | 111 +++++++++++++++++++ HDOJ/1625_autoAC.cpp | 47 ++++++++ HDOJ/1626_autoAC.cpp | 53 +++++++++ HDOJ/1627_autoAC.cpp | 55 +++++++++ HDOJ/1628_autoAC.cpp | 18 +++ HDOJ/1629_autoAC.cpp | 135 ++++++++++++++++++++++ HDOJ/1631_autoAC.cpp | 72 ++++++++++++ HDOJ/1632_autoAC.cpp | 80 +++++++++++++ HDOJ/1633_autoAC.cpp | 80 +++++++++++++ HDOJ/1635_autoAC.cpp | 70 ++++++++++++ HDOJ/1638_autoAC.cpp | 67 +++++++++++ HDOJ/1641_autoAC.cpp | 53 +++++++++ HDOJ/1650_autoAC.cpp | 38 +++++++ HDOJ/1659_autoAC.cpp | 65 +++++++++++ HDOJ/1661_autoAC.cpp | 58 ++++++++++ HDOJ/1662_autoAC.cpp | 164 +++++++++++++++++++++++++++ HDOJ/1663_autoAC.cpp | 40 +++++++ HDOJ/1664_autoAC.cpp | 110 ++++++++++++++++++ HDOJ/1667_autoAC.cpp | 68 ++++++++++++ HDOJ/1668_autoAC.cpp | 86 ++++++++++++++ HDOJ/1669_autoAC.cpp | 89 +++++++++++++++ HDOJ/1671_autoAC.cpp | 37 +++++++ HDOJ/1672_autoAC.cpp | 51 +++++++++ HDOJ/1673_autoAC.cpp | 18 +++ HDOJ/1676_autoAC.cpp | 98 ++++++++++++++++ HDOJ/1677_autoAC.cpp | 46 ++++++++ HDOJ/1678_autoAC.cpp | 23 ++++ HDOJ/1679_autoAC.cpp | 49 ++++++++ HDOJ/1680_autoAC.cpp | 105 ++++++++++++++++++ HDOJ/1681_autoAC.cpp | 35 ++++++ HDOJ/1683_autoAC.cpp | 36 ++++++ HDOJ/1684_autoAC.cpp | 67 +++++++++++ HDOJ/1685_autoAC.cpp | 65 +++++++++++ HDOJ/1686_autoAC.cpp | 64 +++++++++++ HDOJ/1687_autoAC.cpp | 41 +++++++ HDOJ/1688_autoAC.cpp | 92 +++++++++++++++ HDOJ/1689_autoAC.cpp | 72 ++++++++++++ HDOJ/1690_autoAC.cpp | 63 +++++++++++ HDOJ/1691_autoAC.cpp | 259 +++++++++++++++++++++++++++++++++++++++++++ HDOJ/1692_autoAC.cpp | 34 ++++++ HDOJ/1693_autoAC.cpp | 66 +++++++++++ HDOJ/1695_autoAC.cpp | 40 +++++++ HDOJ/1698_autoAC.cpp | 28 +++++ 57 files changed, 3986 insertions(+) create mode 100644 HDOJ/1603_autoAC.cpp create mode 100644 HDOJ/1606_autoAC.cpp create mode 100644 HDOJ/1608_autoAC.cpp create mode 100644 HDOJ/1609_autoAC.cpp create mode 100644 HDOJ/1611_autoAC.cpp create mode 100644 HDOJ/1613_autoAC.cpp create mode 100644 HDOJ/1614_autoAC.cpp create mode 100644 HDOJ/1615_autoAC.cpp create mode 100644 HDOJ/1616_autoAC.cpp create mode 100644 HDOJ/1617_autoAC.cpp create mode 100644 HDOJ/1619_autoAC.cpp create mode 100644 HDOJ/1620_autoAC.cpp create mode 100644 HDOJ/1621_autoAC.cpp create mode 100644 HDOJ/1622_autoAC.cpp create mode 100644 HDOJ/1623_autoAC.cpp create mode 100644 HDOJ/1625_autoAC.cpp create mode 100644 HDOJ/1626_autoAC.cpp create mode 100644 HDOJ/1627_autoAC.cpp create mode 100644 HDOJ/1628_autoAC.cpp create mode 100644 HDOJ/1629_autoAC.cpp create mode 100644 HDOJ/1631_autoAC.cpp create mode 100644 HDOJ/1632_autoAC.cpp create mode 100644 HDOJ/1633_autoAC.cpp create mode 100644 HDOJ/1635_autoAC.cpp create mode 100644 HDOJ/1638_autoAC.cpp create mode 100644 HDOJ/1641_autoAC.cpp create mode 100644 HDOJ/1650_autoAC.cpp create mode 100644 HDOJ/1659_autoAC.cpp create mode 100644 HDOJ/1661_autoAC.cpp create mode 100644 HDOJ/1662_autoAC.cpp create mode 100644 HDOJ/1663_autoAC.cpp create mode 100644 HDOJ/1664_autoAC.cpp create mode 100644 HDOJ/1667_autoAC.cpp create mode 100644 HDOJ/1668_autoAC.cpp create mode 100644 HDOJ/1669_autoAC.cpp create mode 100644 HDOJ/1671_autoAC.cpp create mode 100644 HDOJ/1672_autoAC.cpp create mode 100644 HDOJ/1673_autoAC.cpp create mode 100644 HDOJ/1676_autoAC.cpp create mode 100644 HDOJ/1677_autoAC.cpp create mode 100644 HDOJ/1678_autoAC.cpp create mode 100644 HDOJ/1679_autoAC.cpp create mode 100644 HDOJ/1680_autoAC.cpp create mode 100644 HDOJ/1681_autoAC.cpp create mode 100644 HDOJ/1683_autoAC.cpp create mode 100644 HDOJ/1684_autoAC.cpp create mode 100644 HDOJ/1685_autoAC.cpp create mode 100644 HDOJ/1686_autoAC.cpp create mode 100644 HDOJ/1687_autoAC.cpp create mode 100644 HDOJ/1688_autoAC.cpp create mode 100644 HDOJ/1689_autoAC.cpp create mode 100644 HDOJ/1690_autoAC.cpp create mode 100644 HDOJ/1691_autoAC.cpp create mode 100644 HDOJ/1692_autoAC.cpp create mode 100644 HDOJ/1693_autoAC.cpp create mode 100644 HDOJ/1695_autoAC.cpp create mode 100644 HDOJ/1698_autoAC.cpp diff --git a/HDOJ/1603_autoAC.cpp b/HDOJ/1603_autoAC.cpp new file mode 100644 index 0000000..14d707d --- /dev/null +++ b/HDOJ/1603_autoAC.cpp @@ -0,0 +1,168 @@ +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#define N 1005*1005 +#define RN 1005 +#define M 1005 +struct DLX +{ + int n,m,C; + int U[N],D[N],L[N],R[N],Row[N],Col[N]; + int H[M],S[M],cnt,ans[M]; + void init(int _n,int _m) + { + n=_n; + m=_m; + for(int i=0; i<=m; i++) + { + U[i]=D[i]=i; + L[i]=(i==0?m:i-1); + R[i]=(i==m?0:i+1); + S[i]=0; + } + C=m; + for(int i=1; i<=n; i++) H[i]=-1; + } + void link(int x,int y) + { + C++; + Row[C]=x; + Col[C]=y; + S[y]++; + U[C]=U[y]; + D[C]=y; + D[U[y]]=C; + U[y]=C; + if(H[x]==-1) H[x]=L[C]=R[C]=C; + else + { + L[C]=L[H[x]]; + R[C]=H[x]; + R[L[H[x]]]=C; + L[H[x]]=C; + } + } + void del(int x) + { + R[L[x]]=R[x]; + L[R[x]]=L[x]; + for(int i=D[x]; i!=x; i=D[i]) + { + for(int j=R[i]; j!=i; j=R[j]) + { + U[D[j]]=U[j]; + D[U[j]]=D[j]; + S[Col[j]]--; + } + } + } + void rec(int x) + { + for(int i=U[x]; i!=x; i=U[i]) + { + for(int j=L[i]; j!=i; j=L[j]) + { + U[D[j]]=j; + D[U[j]]=j; + S[Col[j]]++; + } + } + R[L[x]]=x; + L[R[x]]=x; + } + int dance(int x) + { + if(R[0]==0 || R[0]>16) + { + cnt=x; + return 1; + } + int now=R[0]; + for(int i=R[0]; i!=0 && i<=16; i=R[i]) + { + if(S[i] +#include +#include +#include +using namespace std; +struct p{ + char s[100]; + int num; +}a[100]; +bool cmp(p a,p b) +{ + return a.num>b.num; +} +int main() +{ + int n,m,i,j,z=1; + char b[100]; + while(scanf("%d%d",&n,&m)!=EOF) + { + memset(a,0,sizeof(a)); + getchar(); + mapq; + for(i=0;i=65&&x[j]<=90) + x[j]+=32; + } + for(j=0;j=97&&x[j]<=122) + w=w+x[j]; + else + { + map::iterator it; + it=q.find(w); + if(it!=q.end()) + a[i].num++; + w=""; + } + } + } + sort(a,a+m,cmp); + int v=a[0].num; + printf("Excuse Set #%d\n",z); + z++; + for(i=0;i +#include +#include +#include +#include +#include +using namespace std; +int x[39][39]; +int n; +int dx[] = {1,0,-1,0}; +int dy[] = {0,1,0,-1}; +struct node +{ + int x,y,len,dir; + int move; +} re[19]; +bool oor(int x,int y) +{ + if(x<0||x>29) return false; + if(y<0||y>29) return false; + return true; +} +bool stop[19],cash[19]; +int map_move[39][39]; +void init() +{ + int l,r,c; + char d[5]; + memset(map_move,-1,sizeof(map_move)); + memset(x,false,sizeof(x)); + for(int i=0; i0) + { + re[i].x-=dx[re[i].dir]; + re[i].y-=dy[re[i].dir]; + re[i].len--; + if(re[i].len<=0) re[i].move = 0; + } + } + if(map_move[re[i].x][re[i].y]!=-1&&map_move[re[i].x][re[i].y]!=i) + { + re[map_move[re[i].x][re[i].y]].move = 0; + re[i].move = 0; + x[re[i].x][re[i].y] = true; + } + map_move[re[i].x][re[i].y]=i; + map_move[re[i].x-dx[re[i].dir]*(re[i].len)][re[i].y-dy[re[i].dir]*(re[i].len)]=-1; + } + } + } + cout<<" 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2"< +#include +#include +#include +using namespace std; +const int N = 15; +const int M = 105; +int t, p, c, m, vis[M], have[M], hn, b[M], s[M], ans[N], num; +struct Mi { + int num[N]; + int vis[M]; + int b, w; +} mi[M]; +void init() { + int i, j; + memset(vis, 0, sizeof(vis)); + memset(b, 0, sizeof(b)); + memset(s, 0, sizeof(s)); + hn = 0; + scanf("%d%d%d", &p, &c, &m); + for (i = 0; i < m; i++) { + memset(mi[i].vis, 0, sizeof(mi[i].vis)); + for (j = 0; j < p; j++) { + scanf("%d", &mi[i].num[j]); + mi[i].vis[mi[i].num[j]]++; + if (!vis[mi[i].num[j]]) { + vis[mi[i].num[j]] = 1; + have[hn++] = mi[i].num[j]; + } + } + scanf("%d%d", &mi[i].b, &mi[i].w); + } + for (i = 1; i <= c; i++) + if (!vis[i]) { + have[hn++] = i; + break; + } + sort(have, have + hn); +} +bool dfs(int d) { + if (d == p) { + for (int i = 0; i < m; i++) { + if (b[i] != mi[i].b || s[i] - b[i] != mi[i].w) + return false; + } + for (int j = 0; j < p - 1; j++) + printf("%d ", ans[j]); + printf("%d\n", ans[p - 1]); + return true; + } + for (int i = 0; i < hn; i++) { + int num = have[i], flag = 0, j, flag2[M]; + memset(flag2, 0, sizeof(flag2)); + for (j = 0; j < m; j++) { + if (num == mi[j].num[d]) + b[j]++; + if (mi[j].vis[num]) { + s[j]++; + mi[j].vis[num]--; + flag2[j] = 1; + } + if (b[j] > mi[j].b || s[j] > mi[j].b + mi[j].w) + flag = 1; + } + if (!flag) { + ans[d] = num; + if (dfs(d + 1)) return true; + } + for (j = 0; j < m; j++) { + if (num == mi[j].num[d]) + b[j]--; + if (flag2[j]) { + s[j]--; + mi[j].vis[num]++; + } + } + } + return false; +} +int main() { + scanf("%d", &t); + while (t--) { + init(); + if (!dfs(0)) printf("You are cheating!\n"); + } + return 0; +} diff --git a/HDOJ/1611_autoAC.cpp b/HDOJ/1611_autoAC.cpp new file mode 100644 index 0000000..d22246d --- /dev/null +++ b/HDOJ/1611_autoAC.cpp @@ -0,0 +1,44 @@ +#include +#include +#include +using namespace std ; +int cost[200][200],price[200][200],indexx[200][200] ; +void print(int K,int L,char key[],char let[]) +{ + if( K == 0 ) return ; + print(K-1, L-indexx[K][L],key,let) ; + printf("%c: ",key[K-1]) ; + for(int i = L-indexx[K][L] ; i < L ; i++) + putchar(let[i]) ; + puts("") ; +} +int main() +{ + int T ; + scanf("%d",&T) ; + int K,L ,a[200] ,cnt = 0; + while(T--) + { + char key[200],let[200] ; + cnt++ ; + scanf("%d %d %s %s",&K,&L,key,let) ; + for(int i = 0 ; i < L ; i++) + scanf("%d",&a[i]) ; + memset(price,0x40,sizeof(price)) ; + price[0][0] = 0 ; + for(int i = 1 ; i <= L ; i++) + for(int j = i ; j <= L ; j++) + cost[i][j] = cost[i][j-1]+(j-i+1)*a[j-1] ; + for(int i = 1 ; i <= K ; i++) + for(int j = i ; j <= L ; j++) + for(int k = 1 ; k <= j-i+1 ; k++) + { + if(price[i-1][j-k] + cost[j-k+1][j] <= price[i][j]) + price[i][j] = price[i-1][j-k] + cost[j-k+1][j],indexx[i][j] = k ; + } + printf("Keypad #%d:\n",cnt) ; + print(K,L,key,let) ; + printf("\n") ; + } + return 0 ; +} diff --git a/HDOJ/1613_autoAC.cpp b/HDOJ/1613_autoAC.cpp new file mode 100644 index 0000000..23680d8 --- /dev/null +++ b/HDOJ/1613_autoAC.cpp @@ -0,0 +1,32 @@ +#include +#include +#include +using namespace std; +const int maxn=6; +const int inf=1<<29; +int sum[maxn],val[maxn][maxn]; +char str[maxn][10]={"BCG","BGC","CBG","CGB","GBC","GCB"}; +int main() +{ + while(scanf("%d%d%d",&val[0][0],&val[0][1],&val[0][2])!=EOF) + { + for(int i=1;i<=2;i++) + for(int j=0;j<3;j++) + scanf("%d",&val[i][j]); + sum[0]=val[1][0]+val[2][0]+val[0][2]+val[2][2]+val[0][1]+val[1][1]; + sum[1]=val[1][0]+val[2][0]+val[0][1]+val[2][1]+val[0][2]+val[1][2]; + sum[2]=val[1][2]+val[2][2]+val[0][0]+val[2][0]+val[0][1]+val[1][1]; + sum[3]=val[1][2]+val[2][2]+val[0][1]+val[2][1]+val[0][0]+val[1][0]; + sum[4]=val[1][1]+val[2][1]+val[0][0]+val[2][0]+val[0][2]+val[1][2]; + sum[5]=val[1][1]+val[2][1]+val[0][2]+val[2][2]+val[0][0]+val[1][0]; + int ans=inf,pos; + for(int i=0;isum[i]) + { + ans=sum[i]; + pos=i; + } + printf("%s %d\n",str[pos],ans); + } + return 0; +} diff --git a/HDOJ/1614_autoAC.cpp b/HDOJ/1614_autoAC.cpp new file mode 100644 index 0000000..fb04e4a --- /dev/null +++ b/HDOJ/1614_autoAC.cpp @@ -0,0 +1,71 @@ +#include +#include +#include +#include +using namespace std; +const int MAX = 31; +struct Box{ + int dims[11]; +}boxes[MAX]; +bool g[MAX][MAX]; +int dp[MAX], fa[MAX], n, k; +//check if box a can be nested into box b +bool can_be_nested(Box & a, Box & b, int len){ + for(int i = 0; i < len; ++i){ + if(a.dims[i] >= b.dims[i])return false; + } + return true; +} +int memoized_dfs(int i){ + if(dp[i] != 0)return dp[i]; + int max_len = 0; + for(int j = 1; j <= k; ++j){ + if(g[i][j]){ + int next_len = memoized_dfs(j); + if(next_len > max_len){ + max_len = next_len; + fa[i] = j; + } + } + } + return dp[i] = max_len + 1; +} +int main(int argc, char const *argv[]){ + while(scanf("%d %d", &k, &n) == 2){ + memset(g, false, sizeof(g)); + for(int i = 1; i <= k; ++i){ + for(int j = 0; j < n; ++j){ + scanf("%d", &boxes[i].dims[j]); + } + sort(boxes[i].dims, boxes[i].dims + n); + } + for(int i = 1; i <= k; ++i){ + for(int j = 1; j <= k; ++j){ + if(can_be_nested(boxes[j], boxes[i], n)){ + g[i][j] = true; + } + } + } + vector ans; + for(int i = 1; i <= k; ++i){ + memset(dp, 0, sizeof(dp)); + memset(fa, 0, sizeof(fa)); + int length = memoized_dfs(i); + if(length > ans.size()){ + ans.clear(); + int p = i; + while(p != 0){ + ans.push_back(p); + p = fa[p]; + } + } + } + printf("%d\n", ans.size()); + for(int i = ans.size() - 1; i >= 0; --i){ + if(i < ans.size() - 1)printf(" "); + printf("%d", ans[i]); + } + printf(" \n"); + } + return 0; +} diff --git a/HDOJ/1615_autoAC.cpp b/HDOJ/1615_autoAC.cpp new file mode 100644 index 0000000..0f517e8 --- /dev/null +++ b/HDOJ/1615_autoAC.cpp @@ -0,0 +1,29 @@ +#include +#include +using namespace std; +int main(void) { + for (int i, m, n, nMaxM, nMaxN, nCnt = 0; cin >> i; nCnt = 0) { + bool aFlags[1000001] = {false}; + for (m = 2, nMaxM = (int)sqrt((float)i - 1); m <= nMaxM; ++m) { + nMaxN = (int)sqrt((float)i - m * m); + nMaxN = nMaxN >= m ? m - 1 : nMaxN; + for (n = 1; n <= nMaxN; ++n) { + if (n % 2 != m % 2) { + int a = m, b = n, c; + for(int r; (r = a % b) != 0; a = b, b = r); + if (b == 1) { + ++nCnt; + a = m * m - n * n, b = 2 * m * n, c = m * m + n * n; + for (int k = 0; c * k <= i; ++k) { + aFlags[a * k] = aFlags[b * k] = aFlags[c * k] = 1; + } + } + } + } + } + cout << nCnt << ' '; + for (nCnt = 0, m = 1; m <= i; nCnt += !aFlags[m++]); + cout << nCnt << endl; + } + return 0; +} diff --git a/HDOJ/1616_autoAC.cpp b/HDOJ/1616_autoAC.cpp new file mode 100644 index 0000000..8a87835 --- /dev/null +++ b/HDOJ/1616_autoAC.cpp @@ -0,0 +1,104 @@ +#include +#include +#include +int num,top,ii; +struct node +{ + int x; + int y; +}a[105],mis[50005]; +struct +{ + node b[25]; + int to; +}an[25]; +int cmp(const void *c,const void *d) +{ + int ans; + struct node *p1=(node *)c; + struct node *p2=(node *)d; + ans=(p1->x-a[0].x)*(p2->y-a[0].y)-(p2->x-a[0].x)*(p1->y-a[0].y); + if (ans>0) return -1; + else if (ans<0) return 1; + else + { + if (abs(a[0].x-p1->x)x)) return 1; + return -1; + } +} +int find( int p2,int p1,int p0) +{ + return (an[ii].b[p1].x-an[ii].b[p0].x)*(a[p2].y-an[ii].b[p0].y)-(a[p2].x-an[ii].b[p0].x)*(an[ii].b[p1].y-an[ii].b[p0].y); +} +int find2( node p2,node p1,node p0) +{ + return (p1.x-p0.x)*(p2.y-p0.y)-(p2.x-p0.x)*(p1.y-p0.y); +} +void Graham(int n) +{ + int i; + a[n]=a[num]; + a[num]=a[0]; + a[0]=a[n]; + qsort(a+1,n-1,sizeof(a[0]),cmp); + an[ii].b[0]=a[0]; + an[ii].b[1]=a[1]; + top=1; + for (i=2;i +void writesel(int n,int max,char now[]) +{ + char thenew='a'+n-1;int space,i,j; + char * p; + for(i=0;i>n; + char *p=new char[n]; + std::cout<<"program sort(input,output);"< +#include +#include +#include +using namespace std; +const int NM=205; +const int MAX=0xfffffff; +int d[3][2]={-1,1,0,1,1,1}; +int a[NM][NM],dp[NM][NM],path[NM],c[3],n,m,k; +bool flag; +inline int min(int x,int y){ + return xn) x1=1; + dp[x][y]=min(dp[x][y],DFS(x1,y1)); + } + return dp[x][y]=dp[x][y]+a[x][y]; +} +void Findp(int x,int y) +{ + int x1,y1,i; + if(flag) return; + path[k++]=x; + if(y==m){ + flag=true;return; + } + for(i=0;i<3;i++){ + x1=x+d[i][0]; + if(!x1) x1=n;if(x1>n) x1=1; + c[i]=x1; + } + sort(c,c+3); + for(i=0;i<3;i++){ + y1=y+d[i][1]; + if(dp[x][y]==dp[c[i]][y1]+a[x][y]) + Findp(c[i],y1); + } +} +int main() +{ + int i,j,u,mmin; + while(~scanf("%d%d",&n,&m)){ + for(i=1;i<=n;i++) + for(j=1;j<=m;j++){ + scanf("%d",&a[i][j]); + dp[i][j]=MAX; + } + u=1;mmin=MAX; + for(i=1;i<=n;i++){ + if(mmin>DFS(i,1)){ + mmin=dp[i][1],u=i; + } + } + k=0;flag=false; + memset(path,0,sizeof(path)); + Findp(u,1); + for(i=0;i +#include +#include +using namespace std; +#define MAXN 55 +#define DANGEROUS 0 +#define SAFE 1 +struct status +{ + int x, y; + string direction; +}; +int grid[MAXN][MAXN], width, height; +bool move(status & s, string instructions) +{ + status last; + for (int i = 0; i < instructions.length(); i++) + { + last = s; + if (s.direction == "N" && instructions[i] == 'L') + s.direction = "W"; + else if (s.direction == "N" && instructions[i] == 'R') + s.direction = "E"; + else if (s.direction == "N" && instructions[i] == 'F') + s.y += 1; + else if (s.direction == "S" && instructions[i] == 'L') + s.direction = "E"; + else if (s.direction == "S" && instructions[i] == 'R') + s.direction = "W"; + else if (s.direction == "S" && instructions[i] == 'F') + s.y -= 1; + else if (s.direction == "W" && instructions[i] == 'L') + s.direction = "S"; + else if (s.direction == "W" && instructions[i] == 'R') + s.direction = "N"; + else if (s.direction == "W" && instructions[i] == 'F') + s.x -= 1; + else if (s.direction == "E" && instructions[i] == 'L') + s.direction = "N"; + else if (s.direction == "E" && instructions[i] == 'R') + s.direction = "S"; + else if (s.direction == "E" && instructions[i] == 'F') + s.x += 1; + if (s.x > width || s.x < 0 || s.y > height || s.y < 0) + { + if (grid[last.y][last.x] == DANGEROUS) + s = last; + else + { + cout << last.x << " " << last.y << " " << last. + direction; + cout << " LOST" << endl; + grid[last.y][last.x] = DANGEROUS; + return true; + } + } + } + cout << s.x << " " << s.y << " " << s.direction << endl; + return false; +} +int main(int argc, char const *argv[]) +{ + status robot; + string line; + cin >> width >> height; + for (int i = 0; i <= height; i++) + for (int j = 0; j <= width; j++) + grid[i][j] = SAFE; + while (cin >> robot.x >> robot.y >> robot.direction) + { + cin >> line; + move(robot, line); + } + return 0; +} diff --git a/HDOJ/1621_autoAC.cpp b/HDOJ/1621_autoAC.cpp new file mode 100644 index 0000000..73e373e --- /dev/null +++ b/HDOJ/1621_autoAC.cpp @@ -0,0 +1,34 @@ +#include +#include +#include +using namespace std; +int xiede(double m,double n) +{ + double gen3=1.732051; + int max,x,y; + x=(int)(2*gen3*(m-1)/3.0); + if(m>=1)x++; + y=(int)n; + max=x*y; + if(n-y<0.50000) + max=max-(int)(x/2); + return max; +} +int main() +{ + double m,n,gen3=1.732051; + int aa,bb,max1,max2,max3,max23,x,y; + while(~scanf("%lf%lf",&m,&n)) + { + aa=(int)m;bb=(int)n; + max1=aa*bb; + max2=xiede(m,n); + max3=xiede(n,m); + max23=max2>=max3?max2:max3; + if(max1>=max23) + printf("%d grid\n",max1); + else + printf("%d skew\n",max23); + } + return 0; +} diff --git a/HDOJ/1622_autoAC.cpp b/HDOJ/1622_autoAC.cpp new file mode 100644 index 0000000..62c2d42 --- /dev/null +++ b/HDOJ/1622_autoAC.cpp @@ -0,0 +1,88 @@ +#include +#include +#include +#include +#include +#include +#include +using std::queue; +using std::vector; +const int Max_N = 260; +struct Node { + int v, vis; + Node *ch[2]; + inline void set(int _v, Node *p) { + vis = 0, v = _v; + ch[0] = ch[1] = p; + } +}; +struct BinTree { + int fail; + char buf[Max_N]; + Node *tail, *root, stack[Max_N]; + void init() { + fail = 0; + tail = &stack[0]; + } + inline Node *newNode(int v = 0) { + Node *p = tail++; + p->set(v, NULL); + return p; + } + inline void insert(const char *src, const int v) { + int n = strlen(src); + Node *x = root; + for (int i = 0; i < n; i++) { + if (src[i] == 'L') { + if (!x->ch[0]) x->ch[0] = newNode(); + x = x->ch[0]; + } else if (src[i] == 'R') { + if (!x->ch[1]) x->ch[1] = newNode(); + x = x->ch[1]; + } + } + if (x->vis) fail = 1; + x->v = v; + x->vis = 1; + } + inline void bfs() { + vector ans; + queue que; + que.push(root); + while (!que.empty()) { + Node *u = que.front(); que.pop(); + if (!u->vis) { + fail = 1; + break; + } + ans.push_back(u->v); + if (u->ch[0]) que.push(u->ch[0]); + if (u->ch[1]) que.push(u->ch[1]); + } + if (fail) { + puts("not complete"); + return; + } + int n = ans.size(); + for (int i = 0; i < n; i++) { + printf("%d%c", ans[i], i < n - 1 ? ' ' : '\n'); + } + } + inline int gogo() { + init(); + int v = 0; + root = newNode(); + for (;;) { + if (scanf("%s", buf) != 1) return 0; + if (!strcmp(buf, "()")) break; + sscanf(&buf[1], "%d", &v); + insert(strchr(buf, ',') + 1, v); + } + bfs(); + return 1; + } +}tree; +int main() { + while (tree.gogo()); + return 0; +} diff --git a/HDOJ/1623_autoAC.cpp b/HDOJ/1623_autoAC.cpp new file mode 100644 index 0000000..e6e90fc --- /dev/null +++ b/HDOJ/1623_autoAC.cpp @@ -0,0 +1,111 @@ +#include +#include +#include +#include +#define MAXN 400 +char title[204][MAXN]; +char keyword[52][14]; +typedef struct charter{ + char character[MAXN]; + int rank; + int start, end; +}charter; +charter mes[3004]; +int dealenter(char *temp) +{ + int len = strlen(temp); + if(temp[len-1] == '\n') temp[len-1] = ' '; + else temp[len++] = ' ', temp[len] = '\0'; + return 0; +} +int calculate(int n1, int n2, int n3) +{ + int i, j, k, flag; + charter temp; + for(i=0; i 0) + { + flag = 0; + temp = mes[j], mes[j] = mes[j+1], mes[j+1] = temp; + } + } + if(flag) break; + } + return 0; +} +int shuai(int n1, char *from) +{ + int i, j, flag = 0; + for(i=0; i +#include +#include +using namespace std; +#define MAXN 55 +int path[MAXN][MAXN]; +int m,n; +void floyd(){ + for(int k=0;k<=n;k++){ + for(int i=0;i<=n;i++){ + for(int j=0;j<=n;j++){ + path[i][j]+=path[i][k]*path[k][j]; + } + } + } + for(int i=0;i<=n;i++)if(path[i][i]){ + path[i][i]=-1; + for(int j=0;j<=n;j++){ + for(int k=0;k<=n;k++){ + if(path[j][i]&&path[i][k]){ + path[j][k]=-1; + } + } + } + } +} +int main(){ + int u,v,t=0; + while(~scanf("%d",&m)){ + memset(path,0,sizeof(path)); + n=0; + for(int i=1;i<=m;i++){ + scanf("%d%d",&u,&v); + path[u][v]=1; + n=max(n,max(u,v)); + } + printf("matrix for city %d\n",t++); + floyd(); + for(int i=0;i<=n;i++){ + for(int j=0;j +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int radix=256*256; +int main() +{ + string s; + long long r; + while(getline(cin,s)) + { + if(s[0]=='#')break; + if(s.length()==0) + { + cout<<"00 00"<9)cout<<(char)('A'+c-10); + else cout<9)cout<<(char)('A'+c-10); + else cout<9)cout<<(char)('A'+c-10); + else cout<9)cout<<(char)('A'+c-10); + else cout< +#include +#include +using namespace std; +const int maxn=10001; +int n,m,ans[maxn]; +void DFS(int cur) +{ + for(int i=0;i +#include +using namespace std; +int main(void) { + for (int n, k; cin >> n >> k && n * k != 0; ) { + vector Circle; + for (int i = 0; i < n; Circle.push_back(++i)); + for (int m = (k - 1) % Circle.size(), t; Circle.size() != 1; ) { + t = (m - 1 + k) % (Circle.size() - 1); + t = (t + (t >= m)) % Circle.size(); + Circle[m] = Circle[t]; + Circle.erase(Circle.begin() + t); + m = (m - (t < m) + k) % Circle.size(); + } + cout << (n - Circle.front() + 1) % n + 1 << endl; + } + return 0; +} diff --git a/HDOJ/1629_autoAC.cpp b/HDOJ/1629_autoAC.cpp new file mode 100644 index 0000000..80918dd --- /dev/null +++ b/HDOJ/1629_autoAC.cpp @@ -0,0 +1,135 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +struct Card +{ + char num; + char flower; + int num_flag; +}; +Card p[5],q[5]; +char str[]= {'A','2','3','4','5','6','7','8','9','T','J','Q','K'}; +string s_name[9]= {"straight-flush","four-of-a-kind","full-house","flush", + "straight","three-of-a-kind","two-pairs","one-pair","highest-card" + }; +int flag[15],count,value[15], solve_flag[10]; +void solve(Card *r,int x) +{ + if(solve_flag[0]) return; + int flag_flush(0); + memset(value,0,sizeof(value)); + memset(flag,0,sizeof(flag)); + for(int j=0; j<13; j++) + if(r[0].num==str[j]) + { + flag[j]=1; + if(!j) flag[13]=1; + value[j]++; + break; + } + for(int i=1; i<5; i++) + { + if(r[i-1].flower!=r[i].flower) flag_flush=1; + for(int j=0; j<13; j++) + if(r[i].num==str[j]) + { + flag[j]=1; + if(!j) flag[13]=1; + value[j]++; + break; + } + } + if(!flag_flush) solve_flag[3]=1; + int y(0),v(0); + if(flag[0]) + { + for(int i=0; i<5; i++) + if(flag[i]) y++; + if(y==5&&!flag_flush) + { + solve_flag[0]=1; + return; + } + if(y==5&&flag_flush) solve_flag[4]=1; + } + y=0; + for(int i=1; i<14; i++) + { + if(flag[i]) y++; + if(y==5&&!flag_flush) + { + solve_flag[0]=1; + return; + } + if(y==5&&flag_flush) + { + solve_flag[4]=1; + break; + } + if(y>=1&&!flag[i]) break; + } + y=v=0; + for(int i=0; i<14; i++) + if(value[i]>=4) solve_flag[1]=1; + else if(value[i]==3) v++; + else if(value[i]==2) y++; + if(v&&y==1) solve_flag[2]=1; + if(v&&!y) solve_flag[5]=1; + if(!v&&y==2) solve_flag[6]=1; + if(!v&&y==1) solve_flag[7]=1; + if(x9) + { + if(c!='\n') gets(s); + count=count-5; + printf("Hand: "); + for(int i=0; i<5; i++) printf("%c%c ",p[i].num,p[i].flower); + printf("Deck: "); + for(int i=0; i +#include +#include +using namespace std; +enum SYMBOL{A, MOD, LA, BA, DA, PREDA, NAM, SE, PC, P, PN, PS, ST, VP, PV, UN}; +bool aVowel[] = {1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0}; +static SYMBOL aConvTbl[14][4] = { + {PREDA, UN, PREDA, PREDA}, {PREDA, UN, UN, PS}, {NAM, UN, UN, PN}, + {LA, UN, PS, PN}, {MOD, UN, PS, VP}, {A, PS, PS, PS}, {PS, UN, UN, P}, + {DA, UN, P, PC}, {BA, PN, P, PC}, {VP, PN, UN, PV}, {PV, UN, PN, ST}, + {PV, UN, UN, ST}, {PC, UN, UN, SE}, {ST, UN, UN, SE}, +}; +SYMBOL Token2Status(const string &str) { + int nNum = str.length(), cLast = str[nNum - 1]; + if (!islower(cLast) || !aVowel[cLast - 'a']) { + return NAM; + } + switch (nNum) { + case 1: return A; + case 5: + nNum = aVowel[str[4] - 'a']; + nNum |= ((aVowel[str[0] - 'a'] << 4) | (aVowel[str[1] - 'a'] << 3)); + nNum |= ((aVowel[str[2] - 'a'] << 2) | (aVowel[str[3] - 'a'] << 1)); + return (nNum == 5 || nNum == 9) ? PREDA : UN; + case 2: + switch (str[0]) { + case 'g': return MOD; + case 'b': return BA; + case 'd': return DA; + case 'l': return LA; + } + } + return UN; +} +int main(void) { + vector Set; + for (string str; cin >> str && str != "#";) { + int nDot = str.find('.'); + if (nDot == str.npos) { + Set.push_back(Token2Status(str)); + continue; + } + str.erase(str.length() - 1); + if (!str.empty()) { + Set.push_back(Token2Status(str)); + } + for (int i = 0; i < 14; ++i) { + SYMBOL *pTbl = aConvTbl[i]; + for (vector::iterator j = Set.begin(); j != Set.end();) { + vector::iterator iBeg = Set.begin(), iEnd = Set.end(); + if (*j != pTbl[0]) { + ++j; + continue; + } + if (pTbl[1] != UN && (j == iBeg || *(j - 1) != pTbl[1])) { + ++j; + continue; + } + if (pTbl[2] != UN && (j == iEnd - 1 || *(j + 1) != pTbl[2])) { + ++j; + continue; + } + j = pTbl[1] != UN ? Set.erase(j - 1) : j; + j = pTbl[2] != UN ? Set.erase(j + 1) - 1 : j; + *j = pTbl[3]; + } + } + cout << (Set.size() == 1 && Set[0] == SE ? "Good" : "Bad!") << endl; + Set.clear(); + } + return 0; +} diff --git a/HDOJ/1632_autoAC.cpp b/HDOJ/1632_autoAC.cpp new file mode 100644 index 0000000..c2d035a --- /dev/null +++ b/HDOJ/1632_autoAC.cpp @@ -0,0 +1,80 @@ +#include +#include +#include +#include +using namespace std; +#define N 155 +#define eps 1e-8 +struct TPoint +{ + double x,y; +}s; +struct TPolygon +{ + int n; + TPoint p[N]; +}ply1,ply2,ans; +double maxdist; +int dblcmp(double a) {return a<-eps?-1:a>eps?1:0;} +double MAX(double a,double b) {return a>b?a:b;} +double cross(TPoint a,TPoint b,TPoint c) +{ + return (b.x-a.x)*(c.y-a.y)-(b.y-a.y)*(c.x-a.x); +} +double plyarea(TPolygon res) +{ + int i; + double area=0; + res.p[res.n]=res.p[0]; + for(i=0;i=0) b.p[t++]=res.p[i]; + if(d1*d2<0) + { + a.x=(s2*res.p[i].x-s1*res.p[i+1].x)/(s2-s1); + a.y=(s2*res.p[i].y-s1*res.p[i+1].y)/(s2-s1); + b.p[t++]=a; + } + } + b.n=t; + return b; +} +int main() +{ + while(scanf("%d",&ply1.n),ply1.n) + { + int i; + double sumarea,area; + for(i=0;i +#include +#include +#include +#include +#include +using namespace std; +struct Point +{ + double x; + double y; +}; +Point p[3]; +//姹㈢Н缁瀵瑰 +double cross(Point O,Point A,Point B) +{ + return fabs((A.x - O.x) * (B.y - O.y) - (B.x - O.x) * (A.y - O.y))/2; +} +bool judge() +{ + for(int i=0; i<3; i++) + { + if(p[i].x!=0 || p[i].y!=0) + { + return true; + } + } + return false; +} +int main() +{ +#ifndef ONLINE_JUDGE + freopen("in.txt","r",stdin); +#endif + while(scanf(" %lf %lf %lf %lf %lf %lf",&p[0].x,&p[0].y,&p[1].x,&p[1].y,&p[2].x,&p[2].y) && judge()) + { + double maxX = 0,minX = 150; + double maxY = 0,minY = 150; + for(int i=0; i<3; i++) + { + if(p[i].x>maxX) + maxX = p[i].x; + if(p[i].y>maxY) + maxY = p[i].y; + if(p[i].x=100) + { + continue; + } + for(int j=ceil(minY); j<=floor(maxY); j++) + { + if(j <= 0 || j>=100) + { + continue; + } + double s = 0; + Point temp; + temp.x = i; + temp.y = j; + s += cross(temp,p[0],p[1]); + s += cross(temp,p[1],p[2]); + s += cross(temp,p[2],p[0]); + if(fabs(area-s)<=1e-8) + { + num++; + } + } + } + printf("%4d\n",num); + } +} diff --git a/HDOJ/1635_autoAC.cpp b/HDOJ/1635_autoAC.cpp new file mode 100644 index 0000000..ebde916 --- /dev/null +++ b/HDOJ/1635_autoAC.cpp @@ -0,0 +1,70 @@ +#include +#include +#include +#include +using namespace std; +static int aMDays[] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334}; +static int aMDaysL[] = {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335}; +bool LeapYear(int Year, bool bNew) { + if (bNew) { + return ((Year % 4 == 0 && Year % 100 != 0) || Year % 400 == 0); + } + return (Year % 4 == 0); +} +int Date2Days(int Year, int Month, int Date, bool bNew) { + --Year; + int Days = Year * 365 + Year / 4 + (bNew ? (Year / 400 - Year / 100) : 0); + Days += ((Month > 2) ? LeapYear(Year + 1, bNew) : 0); + return (Days + aMDays[Month - 1] + Date - 1 - (!bNew * 2)); +} +int main(void) { + const static string aDays[] = {"Sunday", "Monday", "Tuesday", + "Wednesday", "Thursday", "Friday", "Saturday"}; + const static string aMonths[] = {"January", "February", "March", + "April", "May", "June", "July", "August", "September", + "October", "November", "December"}; + const int nDays400Y = 400 * 365 + 100 - 3; + const int nDays100Y = 100 * 365 + 25 - 1; + const int nDays4Y = 4 * 365 + 1, nDays1Y = 365; + for (string str; cin >> str && str != "#";) { + int Day, Date, Month, Year; + Day = find(&aDays[0], &aDays[7], str) - &aDays[0]; + cin >> Date >> str >> Year; + Month = find(&aMonths[0], &aMonths[12], str) - &aMonths[0] + 1; + int nDays = Date2Days(Year, Month, Date, false); + bool bOld2New = true; + if (Day == (nDays + 1) % 7) { + Year = nDays / nDays400Y * 400; + nDays %= nDays400Y; + if (nDays == nDays100Y * 4) { + Year += 300; + nDays -= nDays100Y * 3; + } + else { + Year += nDays / nDays100Y * 100; + nDays %= nDays100Y; + } + } + else { + nDays = Date2Days(Year, Month, Date, true) + 2; + Year = bOld2New = 0; + } + Year += nDays / nDays4Y * 4; + nDays %= nDays4Y; + if (nDays == nDays1Y * 4) { + Year += 3; + nDays -= nDays1Y * 3; + } + else { + Year += nDays / nDays1Y; + nDays %= nDays1Y; + } + int *pMDays = (LeapYear(++Year, bOld2New) ? aMDaysL : aMDays); + for (Month = 0; Month < 12 && pMDays[Month] <= nDays; ++Month); + Date = nDays - pMDays[Month - 1] + 1; + Day = (Date2Days(Year, Month, Date, bOld2New) + 1) % 7; + cout << aDays[Day] << ' ' << Date << (bOld2New ? " " : "* "); + cout << aMonths[Month - 1] << ' ' << Year << endl; + } + return 0; +} diff --git a/HDOJ/1638_autoAC.cpp b/HDOJ/1638_autoAC.cpp new file mode 100644 index 0000000..f9b0dcb --- /dev/null +++ b/HDOJ/1638_autoAC.cpp @@ -0,0 +1,67 @@ +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +map mma; +int main(){ + mma['A'] = 14; + mma['J'] = 11; + mma['Q'] = 12; + mma['K'] = 13; + for(char i = '2' ; i <='9'; i++) mma[i] = i-'0'; + char nuse,card; + while(cin >> nuse && nuse != '#'){ + vector tmp[2]; + queue player[2]; + list stk; + cin >> card; + tmp[1].push_back(mma[card]); + for(int i = 2; i <= 52; i++){ + cin >> nuse >> card; + tmp[i%2].push_back(mma[card]); + } + for(int i = 0; i < 2; i++){ + while(tmp[i].size()){ + player[i].push(tmp[i][tmp[i].size()-1]); + tmp[i].pop_back(); + } + } + int turn = 1,winner; + while(1){ + int times; + bool flag = 0; + if(stk.size()==0) times = 0; + else if(stk.back()>=11) times = stk.back()-10; + else times = 0; + int cnt; + if(times == 0) cnt = 1; + else cnt = times; + for(int i = 0; i < cnt; i++){ + if(player[turn].size()==0){ + winner = !turn; + flag = 1; + break; + }else{ + stk.push_back(player[turn].front()); + player[turn].pop(); + if(stk.back()>=11) break; + } + } + if(flag) break; + if(times && stk.back()<=10){ + while(stk.size()){ + player[!turn].push(stk.front()); + stk.pop_front(); + } + } + turn = !turn; + } + printf("%d%3d\n",winner+1,player[winner].size()); + } + return 0; +} diff --git a/HDOJ/1641_autoAC.cpp b/HDOJ/1641_autoAC.cpp new file mode 100644 index 0000000..9caba4f --- /dev/null +++ b/HDOJ/1641_autoAC.cpp @@ -0,0 +1,53 @@ +#include +#include +int H,K,ans[15],res; +int judge(int target,int cur,int num,int tot,int *A,int end) +{ + int i,j; + if(tot==target) + return 1; + else if(cur==end||num==H) + return 0; + if(judge(target,cur+1,num,tot,A,end)) + return 1; + if(judge(target,cur,num+1,tot+A[cur],A,end)) + return 1; + return 0; +} +void dfs(int cur,int *A,int end) +{ + int i,j; + if(judge(cur,0,0,0,A,end)) + dfs(cur+1,A,end); + if(endres) + { + res=cur-1; + memcpy(ans,A,sizeof(ans)); + } +} +int main() +{ + int i,j,k,A[15]; + while(1) + { + scanf("%d%d",&H,&K); + if(H==0) + break; + memset(A,-1,sizeof(A)); + res=0; + dfs(1,A,0); + for(i=0;i"); + printf("%3d\n",res); + } + return 0; +} diff --git a/HDOJ/1650_autoAC.cpp b/HDOJ/1650_autoAC.cpp new file mode 100644 index 0000000..7d6d663 --- /dev/null +++ b/HDOJ/1650_autoAC.cpp @@ -0,0 +1,38 @@ +#include +#include +#include +typedef std::vector::iterator VECINT_ITER; +int Josephus(int n, int k) +{ +static std::vector vecJosephus(1, 0); +if (n <= (int)vecJosephus.size()) +return vecJosephus[n - 1]; +int j = (Josephus(n - 1, k) + k) % n; +vecJosephus.push_back(j); +return j; +} +int main(void) +{ +for (int i = 0; i < 100000; Josephus(++i, 15)); +for (int nSizeMin, nSizeMax; std::cin >> nSizeMin >> nSizeMax;) +{ +if (nSizeMin > nSizeMax) +std::swap(nSizeMin, nSizeMax); +if (nSizeMin == 0 && nSizeMax == 0) +break; +std::vector vecCover(nSizeMin / 2, 0); +for (int nSize = nSizeMin, nJump = 15; nSize <= nSizeMax; ++nSize) { +int j = Josephus(nSize, nJump); +if (j > nSize / 2) +j = nSize - j; +if (j < vecCover.size()) +vecCover[j] = 1; +} +VECINT_ITER ir = std::find(vecCover.begin() + 1, vecCover.end(), 0); +if (ir == vecCover.end()) +std::cout << "Better estimate needed" << std::endl; +else +std::cout << ir - vecCover.begin() << std::endl; +} +return 0; +} diff --git a/HDOJ/1659_autoAC.cpp b/HDOJ/1659_autoAC.cpp new file mode 100644 index 0000000..b12ae27 --- /dev/null +++ b/HDOJ/1659_autoAC.cpp @@ -0,0 +1,65 @@ +#include +#include +struct node +{int x[50],y[50],z,num; +} a[1000][1000]; +int visit[1000][1000]; +int dfs(int X,int Y) +{int i; + if (a[X][Y].z==0) return a[X][Y].num; + else + { + for (i=1;i<=a[X][Y].z;i++) + a[X][Y].num=a[X][Y].num+dfs(a[X][Y].x[i],a[X][Y].y[i]); + a[X][Y].z=0; + return a[X][Y].num; + } +} +int main() +{int f,t,l,i,j,k,n,m,num,top,tail,column,row,pos; + char s[2000]; + scanf("%d",&t); + while (t--) + {scanf("%d %d",&n,&m); + memset(visit,0,sizeof(visit)); + for (i=1;i<=m;i++) + for (j=1;j<=n;j++) + {a[i][j].z=0;a[i][j].num=0;} + for (i=1;i<=m;i++) + {getchar(); + for (j=1;j<=n;j++) + {scanf("%s",&s); + l=strlen(s); + a[i][j].z=0; + if (s[0]!='=') + {num=0; f=0; if (s[0]=='-') f=1; + for (k=f;k='A')&&(s[pos]<='Z')) {column=column*26+s[pos]-'A'+1; ++pos;} + while ((pos='0')&&(s[pos]<='9')) {row=row*10+s[pos]-'0'; ++pos;} + if ((visit[row][column]==1)||((i==row)&&(j==column))) a[i][j].num=a[i][j].num+a[row][column].num; + else {++a[i][j].z;a[i][j].x[a[i][j].z]=row; a[i][j].y[a[i][j].z]=column;} + row=0; column=0; ++pos; + } + } + } + } + for (i=1;i<=m;i++) + for (j=1;j<=n;j++) + if (a[i][j].z>0) dfs(i,j); + for (i=1;i<=m;i++) + {for (j=1;j +#include +#include +#include +#include +#include +using namespace std; +const int maxn = 1003; +struct Point +{ + int x,y; + double rad; + bool operator<(const Point &rhs) const { + return rad < rhs.rad; + } +}P[maxn]; +int col[maxn]; +Point tmp[maxn]; +bool cmp(const Point& a,const Point& b) //anticlockwise sort +{ + return a.x*b.y >= b.x*a.y; +} +int solve(int n) +{ + if(n<=3) return n; + int ans = -1; + for(int pivot = 0; pivot < n; pivot++){ + int k = 0; + for(int i = 0; i < n; i++) if(i!=pivot){ + tmp[k].x = P[i].x - P[pivot].x; + tmp[k].y = P[i].y - P[pivot].y; + if(col[i]) { tmp[k].x = - tmp[k].x; tmp[k].y = -tmp[k].y; } + tmp[k].rad = atan2(tmp[k].y, tmp[k].x); + k++; + } + sort(tmp,tmp+k); + int L = 0, R = 0, sum = 1; + while(L +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long int64; +typedef unsigned long long uint64; +typedef pair PII; +typedef pair PLL; +typedef pair PCC; +typedef pair PDD; +#define MP make_pair +#define PB push_back +#define SZ(a) ((int)(a).size()) +#define X first +#define Y second +#define L(x) ((x)<<1) +#define R(x) ((x)<<1 | 1) +#define max3(x, y, z) (max(max((x), (y)), (z))) +#define min3(x, y, z) (min(min((x), (y)), (z))) +#define BIT(x, i) (((x) >> (i)) & 1) +#define FOR(it, c) for( TYPE((c).begin()) it = (c).begin(); it != (c).end(); it++) +const double PI = 2.0*acos(0.0); +const double EPS = 1e-6; +#define GREATER(x, y) ((x) > (y) + EPS) +#define GREATER_EQUAL(x, y) ((x) > (y) - EPS) +#define LESS(x, y) ((x) < (y) - EPS) +#define LESS_EQUAL(x, y) ((x) < (y) + EPS) +#define EQUAL(x, y) (abs((x) - (y)) < EPS) +#define MAX_N 35 +#define MAX_M 1005 +#define MAXX 0x3f +#define UPPER 2147483647LL +#define INT_MAX 2147483647 +#define INF (1<<29) +#define BINF (1LL<<60) +#define NONE -1 +#define NIL 0 +struct data{ + char alpha; + char dir; + data(){} + data(char alpha, char dir) :alpha(alpha), dir(dir){} +} tile[MAX_N][MAX_N]; +const int OFFR[] = { 1, 0, -1, 0 }; +const int OFFC[] = { 0, 1, 0, -1 }; +int n, m; +bool try_to_remove(int sx, int sy, int line_cnt){ + bool visit[2][MAX_N][MAX_N]; + memset(visit, false, sizeof(visit)); + visit[0][sx][sy] = true; + int p = 0; + for (int ln = 1; ln <= line_cnt; ln++){ + vector V; + memset(visit[p ^ 1], false, sizeof(visit[p ^ 1])); + for (int r = 0; r <= n + 1; r++) for (int c = 0; c <= m + 1; c++) if (visit[p][r][c]){ + visit[p ^ 1][r][c] = true; + for (int k = 0; k < 4; k++){ + int xx = r + OFFR[k]; + int yy = c + OFFC[k]; + while (xx >= 0 && xx <= n + 1 && yy >= 0 && yy <= m + 1){ + if (tile[xx][yy].alpha != '.'){ + if (xx == sx && yy == sy) + break; + if (tile[xx][yy].alpha == tile[sx][sy].alpha) + V.PB(MP(xx, yy)); + break; + } + else + visit[p ^ 1][xx][yy] = true; + xx += OFFR[k]; + yy += OFFC[k]; + } + } + } + sort(V.begin(), V.end()); + if (SZ(V) > 0){ + tile[sx][sy].alpha = tile[V[0].X][V[0].Y].alpha = '.'; + return true; + } + p ^= 1; + } + return false; +} +bool refresh(){ + data tmp[MAX_N][MAX_N]; + for (int r = 1; r <= n; r++) for (int c = 1; c <= m; c++) + tmp[r][c] = tile[r][c]; + bool rsh = false; + for (int r = 1; r <= n; r++) for (int c = 1; c <= m; c++) if (tile[r][c].alpha != '.'){ + int ver = 4; + switch (tile[r][c].dir){ + case 'D': ver = 0; break; + case 'R': ver = 1; break; + case 'U': ver = 2; break; + case 'L': ver = 3; break; + } + if (ver <= 3){ + int pr = r, pc = c; + int nr = pr + OFFR[ver]; + int nc = pc + OFFC[ver]; + if (nr >= 1 && nr <= n && nc >= 1 && nc <= m && tmp[nr][nc].alpha == '.'){ + swap(tmp[pr][pc], tmp[nr][nc]); + rsh = true; + } + } + } + for (int r = 1; r <= n; r++) for (int c = 1; c <= m; c++) + tile[r][c] = tmp[r][c]; + return rsh; +} +void solve(){ + while (true){ + bool move = false; + for (int ln = 1; ln <= 3 && !move; ln++){ + for (int r = 1; r <= n && !move; r++) for (int c = 1; c <= m && !move; c++){ + if (tile[r][c].alpha != '.' && try_to_remove(r, c, ln)) + move = true; + } + } + if (move) + while (refresh()); + else + break; + } +} +int main(){ + int T = 0; + while (~scanf("%d %d", &n, &m) && n + m){ + char tmp[5]; + for (int r = 0; r <= n+1; r++){ + for (int c = 0; c <= m+1; c++){ + if (r == 0 || r == n + 1 || c == 0 || c == m + 1) + tile[r][c] = data('.', 'S'); + else{ + scanf("%s", tmp); + tile[r][c] = data(tmp[0], tmp[1]); + } + } + } + solve(); + printf("Case %d\n", ++T); + for (int r = 1; r <= n; r++){ + for (int c = 1; c <= m; c++) + putchar(tile[r][c].alpha); + puts(""); + } + } + return 0; +} diff --git a/HDOJ/1663_autoAC.cpp b/HDOJ/1663_autoAC.cpp new file mode 100644 index 0000000..6cfcd32 --- /dev/null +++ b/HDOJ/1663_autoAC.cpp @@ -0,0 +1,40 @@ +#include +#include +#include +using namespace std; +int a,b; +long long A[10],B[10]; +void dp(int s,long long *p,int t) +{ + if(s<=0) return; + int x=s/10,y=s%10; + for(int i=1;i<=y;i++) p[i]+=t; + while(x) + { + p[x%10]+=(y+1)*t; + x/=10; + } + for(int i=0;i<=9;i++) p[i]+=t*(s/10); + t*=10; + dp(s/10-1,p,t); +} +int main() +{ + while(scanf("%d%d",&a,&b)&&b!=0) + { + memset(A,0,sizeof(A)); + memset(B,0,sizeof(B)); + if(ab) + { + dp(a,A,1); + dp(b,B,1); + } + for(int i=0;i<9;i++) + printf("%I64d ",A[i]-B[i]); + printf("%I64d\n",A[9]-B[9]); + } + return 0; +} diff --git a/HDOJ/1664_autoAC.cpp b/HDOJ/1664_autoAC.cpp new file mode 100644 index 0000000..7b1b1e7 --- /dev/null +++ b/HDOJ/1664_autoAC.cpp @@ -0,0 +1,110 @@ +#include +const int N = 65536; +const int M = N+N; +int x[2][N]={0},q[M]={0},p[M]={0}; +int bfs(int a,int b,int n,int t) +{ + int fr=0,r=1,i=0; + char f[N]={0}; + q[0]=0; + if (a==0) + { + fr=2; + q[2]=b; + r=3; + f[0]=1; + p[2]=0; + } + while(fr0;j--) + printf("%d",c); + } + else{ + m=n; + t=0; + for (i=0;i<10;i++) + { + for (j=i+1;j<10;j++) + { + c=bfs(i,j,n,t); + if (c!=-1 && c=0;k--) + { + if (x[t][k]x[1-t][k]) + break; + } + } + } + } + for (i=m;i>=0;i--) + printf("%d",x[1-t][i]); + } + printf("\n"); + scanf("%d",&n); + } + return 0; +} diff --git a/HDOJ/1667_autoAC.cpp b/HDOJ/1667_autoAC.cpp new file mode 100644 index 0000000..d93e1dc --- /dev/null +++ b/HDOJ/1667_autoAC.cpp @@ -0,0 +1,68 @@ +#include +#define size 24 +using namespace std; +const int opt[][size] = +{ + { 2, 1, 6, 3, 4, 5, 11, 7, 8, 9, 10, 15, 12, 13, 14, 20, 16, 17, 18, 19, 22, 21, 0, 23 }, + { 0, 3, 2, 8, 4, 5, 6, 7, 12, 9, 10, 11, 17, 13, 14, 15, 16, 21, 18, 19, 20, 23, 22, 1 }, + { 0, 1, 2, 3, 10, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23 }, + { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 19, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23 }, + { 0, 23, 2, 1, 4, 5, 6, 7, 3, 9, 10, 11, 8, 13, 14, 15, 16, 12, 18, 19, 20, 17, 22, 21 }, + { 22, 1, 0, 3, 4, 5, 2, 7, 8, 9, 10, 6, 12, 13, 14, 11, 16, 17, 18, 19, 15, 21, 20, 23 }, + { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 15, 16, 17, 18, 19, 13, 20, 21, 22, 23 }, + { 0, 1, 2, 3, 5, 6, 7, 8, 9, 10, 4, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23 }, + { 6, 7, 8, 11, 12, 15, 16, 17 }, +}; +const char optlist[] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H' }; +int sharp[size]; +char path[size]; +bool judge(int node[]){ + for (int i = 0; i < 8; i++) + if (node[opt[8][0]] != node[opt[8][i]]) + return false; + return true; +} +int get_h(int node[]){ + int cnt[4] = { 0 }; + for (int i = 0; i < 8; i++) + cnt[node[opt[8][i]]]++; + int max = 0; + for (int i = 1; i <= 3; i++) + max < cnt[i] ? max = cnt[i] : 0; + return 8 - max; +} +bool ida(int curr[], int expr, int depth, char path[]){ + if (expr == depth) { + if (judge(curr)) { + path[expr] = '\0'; + printf("%s\n%d\n", path, curr[6]); + return true; + } + else + return false; + } + if (get_h(curr) + expr > depth) return false; + int next[size]; + for (int i = 0; i < 8; i++){ + for (int j = 0; j < size; j++) next[j] = curr[opt[i][j]]; + path[expr] = optlist[i]; + if (ida(next, expr + 1, depth, path)) return true; + } + return false; +} +int main(){ + while (scanf("%d", sharp), sharp[0]){ + for (int i = 1; i < size; i++){ + scanf("%d", sharp + i); + } + if (judge(sharp)){ + printf("No moves needed\n%d\n", sharp[6]); + continue; + } + for (int i = get_h(sharp);; i++){ + if (ida(sharp, 0, i, path)) + break; + } + } + return 0; +} diff --git a/HDOJ/1668_autoAC.cpp b/HDOJ/1668_autoAC.cpp new file mode 100644 index 0000000..0e8caf2 --- /dev/null +++ b/HDOJ/1668_autoAC.cpp @@ -0,0 +1,86 @@ +#include +#include +#include +#include +using namespace std; +typedef long long ll; +#define N 13 +#define M 8192 +int f[M][N][N]; +ll g[M][N][N]; +int a[N][N]; +int v[N]; +int t, n, m; +void dp() +{ + if (n == 1) + { + cout << v[0] << " " << 1 << endl; + return ; + } + memset(f, 0, sizeof(f)); + memset(g, 0, sizeof(g)); + for (int i = 0; i < n; ++i) + { + f[1 << i][i][i] = v[i]; + g[1 << i][i][i] = 1; + } + m = (1 << n) - 1; + for (int s = 0; s < m; ++s) + for (int i = 0; 1 << i <= s; ++i) + if ((s >> i) & 1) + for (int j = 0; 1 << j <= s; ++j) + if (((s >> j) & 1) && f[s][i][j]) + for (int k = 0; k < n; ++k) + if (!((s >> k) & 1) && a[j][k]) + { + int temp = f[s][i][j] + v[k] + v[j] * v[k]; + if (i != j && a[i][k]) + temp += v[i] * v[j] * v[k]; + int ss = s + (1 << k); + if (temp > f[ss][j][k]) + { + f[ss][j][k] = temp; + g[ss][j][k] = g[s][i][j]; + } + else if (temp == f[ss][j][k]) + { + g[ss][j][k] += g[s][i][j]; + } + } + int ans = 0; + ll ans2 = 0; + for (int i = 0; i < n; ++i) + for (int j = 0; j < n; ++j) + if (f[m][i][j] > ans) + { + ans = f[m][i][j]; + ans2 = g[m][i][j]; + } + else if (f[m][i][j] == ans) + { + ans2 += g[m][i][j]; + } + cout << ans << " " << ans2 / 2 << endl; +} +int main() +{ + ios::sync_with_stdio(0); + scanf("%d", &t); + while (t--) + { + memset(a, 0, sizeof(a)); + scanf("%d%d", &n, &m); + for (int i = 0; i < n; ++i) + scanf("%d", &v[i]); + while (m--) + { + int x, y; + scanf("%d%d", &x, &y); + --x, --y; + a[x][y] = a[y][x] = 1; + } + dp(); + } + return 0; +} diff --git a/HDOJ/1669_autoAC.cpp b/HDOJ/1669_autoAC.cpp new file mode 100644 index 0000000..59f658e --- /dev/null +++ b/HDOJ/1669_autoAC.cpp @@ -0,0 +1,89 @@ +#include +#include +#define N 1005 +#define M 505 +#define CLR(a,v) memset(a,v,sizeof(a)) +struct Edge +{ + int v,next; +}edge[N*M]; +int ehead[N]; +int ecnt; +inline void AddEdge(int u,int v) +{ + edge[ecnt]={v,ehead[u]}; + ehead[u]=ecnt++; +} +int match[M][N]; +int mcnt[N]; +bool vis[M]; +int limit; +bool Find(int u) +{ + for(int i=ehead[u];~i;i=edge[i].next) + { + int v=edge[i].v; + if(vis[v])continue; + vis[v]=true; + if(mcnt[v]'9';c=getchar())if(c=='\n')return false; + a=c-'0'; + for(c=getchar();c>='0'&&c<='9';c=getchar())a=a*10+c-'0'; + lof=c=='\n'; + return true; +} +char s[20]; +int main() +{ + int n,m; + while(scanf("%d%d",&n,&m),n) + { + CLR(ehead,-1);ecnt=0; + for(int i=0;i +#include +#include +#include +#include +using namespace std; +int main() +{ + vector v; + char ch[10]; + string s; + int n; + cin>>n; + int i,j; + while(cin>>n) + { + v.clear(); + for(i=0;i +#include +#include +using namespace std; +const int maxn=1e4+10; +int n,m,map[maxn][3],color[maxn]; +bool vis[maxn]; +bool DFS(int x) +{ + for(int i=0;i<2;i++) + { + int ita=map[x][i]; + if(!vis[ita]) + { + vis[ita]=1; + if(color[ita]==-1||DFS(color[ita])) + { + color[ita]=x; + return true; + } + } + } + return false; +} +int main() +{ + int T; + scanf("%d",&T); + while(T--) + { + memset(color,-1,sizeof(color)); + scanf("%d%d",&m,&n); + for(int i=0;i +int main() +{ + int T,N,min,max,a; + scanf("%d",&T); + while(T--){ + scanf("%d",&N); + min = 0x3f3f3f3f; + max = -0x3f3f3f3f; + while(N--){ + scanf("%d",&a); + if(a>max) max = a; + if(a +#include +#include +#include +#include +#include +#define M 1007 +using namespace std; +int n,m,cap,s,e,num; +int val[M],dp[M][M],head[M]; +struct node +{ + int u,cost,res; + bool operator < (const node a)const + { + return cost>a.cost; + } +}; +struct E +{ + int v,to,dist; +} edg[M*20]; +vectorG[M]; +void addedge(int u,int v,int dist) +{ + edg[num].v=v; + edg[num].dist=dist; + edg[num].to=head[u]; + head[u]=num++; +} +void init() +{ + num=0; + memset(head,-1,sizeof(head)); + memset(val,0,sizeof(val)); + for(int i=0; i q; + q.push((node){s,0,0}); + while(!q.empty()) + { + node x=q.top(); + q.pop(); + int u=x.u,cost=x.cost,res=x.res; + if(u==e) + { + printf("%d\n",cost); + return ; + } + if(rescost+val[u])) + { + dp[u][res+1]=cost+val[u]; + q.push((node){u,dp[u][res+1],res+1}); + } + for(int i=head[u]; i!=-1; i=edg[i].to) + { + int v=edg[i].v,dist=edg[i].dist; + if(rescost) + { + dp[v][res-dist]=cost; + q.push((node){v,cost,res-dist}); + } + } + } + printf("impossible\n"); + return ; +} +int main() +{ + while( scanf("%d%d",&n,&m)!=EOF) + { + init(); + for(int i=0; i +#include +using namespace std; +struct node +{ + int x, y; +}; +int cmp (const void *a, const void *b) +{ + node *c = (node *)a; + node *d = (node *)b; + if (c -> x != d -> x) + return c -> x - d -> x; + else + return d -> y - c -> y; +} +int main () +{ + node stu[21000]; + int t, n, i, j, k, a[21000]; + cin >> t; + while (t--) + { + memset (a, 0, sizeof(a)); + cin >> n; + for (i=0; i> stu[i].x >> stu[i].y; + qsort (stu, n, sizeof (stu[0]), cmp); + a[0] = stu[0].y, k = 1; + for (i=1; i +#include +using namespace std; +bool cmp(int x,int y) +{ return x>y; +} +int main() +{ int t,n,i,sum; + int a[20005]; + scanf("%d",&t); + while(t--) + { scanf("%d",&n);sum=0; + for(i=1;i<=n;i++) + { scanf("%d",&a[i]); + } + sort(a+1,a+n+1,cmp); + for(i=3;i<=n;i+=3) + { sum+=a[i]; + } + printf("%d\n",sum); + } + return 0; +} diff --git a/HDOJ/1679_autoAC.cpp b/HDOJ/1679_autoAC.cpp new file mode 100644 index 0000000..67ed484 --- /dev/null +++ b/HDOJ/1679_autoAC.cpp @@ -0,0 +1,49 @@ +#include +#include +#include +#define inf 1e9; +int h,in[210]; +double e[210][210]; +double dp[210][210]; +double min(double a,double b){ + return a>b?b:a; +} +int main(){ + int t,T,h,c,i,j,k; + scanf("%d",&T); + for(t=1;t<=T;t++){ + scanf("%d %d",&h,&c); + for(i=1;i<=h;i++) + scanf("%d",&in[i]); + for(i=1;i<=h;i++) + for(j=i;j<=h;j++){ + if(j==i){ + e[i][j]=0; + continue; + } + double tem =(double)(in[j]-in[i])/(j-i); + double sum=0; + for(int k=i+1;k=j-1){ + dp[i][j]=min(dp[i][j],dp[k][j-1]+e[k][i]); + } + } + } + } + printf("%.4f\n",dp[h][c]/h); + } +} diff --git a/HDOJ/1680_autoAC.cpp b/HDOJ/1680_autoAC.cpp new file mode 100644 index 0000000..fc387c3 --- /dev/null +++ b/HDOJ/1680_autoAC.cpp @@ -0,0 +1,105 @@ +#include +#include +#include +using namespace std; +#define N 100 +char map[10][10]; +int wx,wy,hx,hy; +int visit[10][10][100]; +int dir[8][2]= {0,1,1,1,1,0,1,-1,0,-1,-1,-1,-1,0,-1,1}; +struct node +{ + int x; + int y; + int step; +} a[N]; +bool judge(node a) +{ + if(a.x==hx+a.step&&(a.y==hy+1||a.y==hy-1))return false; + if(map[a.x][a.y]=='F'||map[a.x][a.y]=='D')return false; + return a.x>=1&&a.y>=1&&a.x<=8&&a.y<=8&&!visit[a.x][a.y][a.step]; +} +int bfs() +{ + memset(visit,0,sizeof(visit)); + int front=0; + int rear=1; + node cur; + a[0].x=wx; + a[0].y=wy; + a[0].step=0; + visit[wx][wy][0]=1; + int flag=1; + int mm=0; + while(front8) + { + return 0; + } + for(int i=0; i<8; i++) + { + int tx=cur.x+dir[i][0]; + int ty=cur.y+dir[i][1]; + int tstep=cur.step+1; + node b; + b.step=tstep; + b.x=tx; + b.y=ty; + if((tx>=1 && tx<=8) && (ty>=1 && ty<=8) && map[tx][ty]!='F' && map[tx][ty]!='D' && visit[tx][ty][tstep]==0) + { + if(!((tx==hx+tstep && ty==hy-1) || (tx==hx+tstep && ty==hy+1))) + { + visit[tx][ty][tstep]=1; + if(tx==hx+cur.step&&ty==hy||tx==hx+tstep&&ty==hy) + { + return 1; + } + node tmp; + tmp.x=tx; + tmp.y=ty; + tmp.step=tstep; + a[rear++]=tmp; + } + } + } + front++; + } + return 0; +} +int main() +{ + int t; + scanf("%d",&t); + while(t--) + { + for(int i=1; i<=8; i++) + { + scanf("%s",map[i]+1); + } + scanf("%d%d",&wx,&wy); + int xx=wx; + wx=9-wy; + wy=xx; + scanf("%d%d",&hx,&hy); + xx=hx; + hx=9-hy; + hy=xx; + int ans=bfs(); + if(ans==1) + { + printf("White\n"); + } + else + printf("Black\n"); + } + return 0; +} diff --git a/HDOJ/1681_autoAC.cpp b/HDOJ/1681_autoAC.cpp new file mode 100644 index 0000000..a5266d2 --- /dev/null +++ b/HDOJ/1681_autoAC.cpp @@ -0,0 +1,35 @@ +#include +#include +bool dp[1010010]; +int main() +{ + int i,a[5],t,count,mem; + scanf("%d",&t); + while(t--) + { + scanf("%d%d%d%d",a,a+1,a+2,a+3); + memset(dp,false,sizeof(dp)); + dp[a[0]]=dp[a[1]]=dp[a[2]]=dp[a[3]]=1; + for(count=0,i=1;i<1000001;i++) + { + if(dp[i]) + { + dp[i+a[0]]=dp[i+a[1]]=dp[i+a[2]]=dp[i+a[3]]=1; + } + else count++,mem=i; + } + for(;i<1010000;i++) + { + if(!dp[i])mem=-1; + else + { + if(i+a[0]<1010000)dp[i+a[0]]=1; + if(i+a[1]<1010000)dp[i+a[1]]=1; + if(i+a[2]<1010000)dp[i+a[2]]=1; + if(i+a[3]<1010000)dp[i+a[3]]=1; + } + } + printf("%d\n%d\n",count,mem); + } + return 0; +} diff --git a/HDOJ/1683_autoAC.cpp b/HDOJ/1683_autoAC.cpp new file mode 100644 index 0000000..a91c7a4 --- /dev/null +++ b/HDOJ/1683_autoAC.cpp @@ -0,0 +1,36 @@ +#include +#include +using namespace std; +char a[101],b[101],c[101]; +int main() +{ + int t,i; + cin>>t; + while(t--) + { + cin>>a>>b>>c; + int len1=strlen(a); + int len2=strlen(b); + int len3=strlen(c); + int j=0; + for(i=0;i<=len2;i++) + { + if(b[i]=='*'||c[i]=='*') + { + j++; + } + else if (a[j]==b[i]||a[j]==c[i]) + { + j++; + } + if(j==len1) + { + cout<<"win"<len2) + cout<<"lose"< +#include +#include +using namespace std; +int dp[101][101]; +int n,m,sal; +struct pro +{ + int p[101],pun,rew; +}pr[101]; +int main() +{ + int T; + scanf("%d",&T); + while(T--) + { + scanf("%d%d%d",&m,&n,&sal); + for(int i=1;i<=m;i++) + { + pr[i].p[0]=0; + for(int j=1;j<=n;j++) + scanf("%d",&pr[i].p[j]); + scanf("%d %d",&pr[i].rew,&pr[i].pun); + } + memset(dp,0,sizeof(dp)); + dp[0][0]=0; + for(int i=1;i<=m;i++) + dp[i][0]=dp[i-1][0]-pr[i].pun*100; + for(int i=1;i<=n;i++) + dp[1][i]=(pr[1].rew-sal*i)*pr[1].p[i]-(100-pr[1].p[i])*pr[1].pun; + for(int i=2;i<=m;i++) + { + for(int j=1;j<=n;j++) + { + dp[i][j]=-INT_MAX; + for(int k=0;k<=j;k++) + { + int temp=dp[i-1][j-k]+(pr[i].rew-sal*k)*pr[i].p[k]-(100-pr[i].p[k])*pr[i].pun; + if(temp>dp[i][j]) + dp[i][j]=temp; + } + } + } + int max1=-INT_MAX; + for(int i=0;i<=n;i++) + { + if(dp[m][i]>max1) + max1=dp[m][i]; + } + printf("%d\n",max1); + int flag=1; + for(int i=0;i<=n;i++) + { + if(max1==dp[m][i]) + { + if(flag) + { + printf("%d",i); + flag=0; + } + else printf(" %d",i); + } + } + printf("\n"); + } + return 0; +} diff --git a/HDOJ/1685_autoAC.cpp b/HDOJ/1685_autoAC.cpp new file mode 100644 index 0000000..12c91c3 --- /dev/null +++ b/HDOJ/1685_autoAC.cpp @@ -0,0 +1,65 @@ +#include +#include +int n,num[15],lim; +bool flag; +int h() +{ + int i,r=0; + if(num[0]!=1) r++; + if(num[n-1]!=n) r++; + for(i=0;i=lim) return; + if(cnt+ceil(h()/3.0)>lim) return; + int len,pos,j,p,temp[15]; + for(i=0;i=n) break; + if(p==i) p+=len; + num[j++]=temp[p++]; + } + dfs(cnt+1); + } + } + } + for(i=0;i +#include +#define MAX 10000 +int next[MAX + 1]; +char pattern[MAX + 1]; +int init_next (char *pattern, int *next); +int KMP (char text, char *pattern, int len); +int main() +{ + int T; + int len; + char text = '\0'; + scanf ("%d", &T); + getchar (); + while (T --) + { + len = init_next (pattern, next); + printf ("%d\n", KMP (text, pattern, len)); + } + return 0; +} +int init_next (char *pattern, int *next) +{ + int q, i = 0; + q = next[0] = -1; + pattern[i ++] = getchar (); + while ((pattern[i] = getchar ()) != '\n') + { + while (q >= 0 && pattern[q + 1] != pattern[i]) + { + q = next[q]; + } + if (pattern[q + 1] == pattern[i]) + { + q ++; + } + next[i] = q; + i ++; + } + return i; +} +int KMP (char text, char *pattern, int len) +{ + int q, i = 0; + int count = 0; + q = -1; + while ((text = getchar ()) != '\n') + { + while (q >= 0 && pattern[q + 1] != text) + { + q = next[q]; + } + if (pattern[q + 1] == text) + { + q ++; + } + if (q == len - 1) + { + q = next[q]; + count ++; + } + } + return count; +} diff --git a/HDOJ/1687_autoAC.cpp b/HDOJ/1687_autoAC.cpp new file mode 100644 index 0000000..351decb --- /dev/null +++ b/HDOJ/1687_autoAC.cpp @@ -0,0 +1,41 @@ +#include +#include +using std::sort; +using std::swap; +double X, Y; +struct Node{ + double left, right; +} arr[102]; +double getX(double a, double b){ + return X - Y * (X - a) / (Y - b); +} +bool cmp(Node a, Node b){ + return a.left < b.left; +} +int main(){ + double x1, y1, x2, y2, flag; + int t, n, ans; + scanf("%d", &t); + while(t--){ + scanf("%d", &n); + scanf("%lf%lf", &X, &Y); + for(int i = 0; i < n; ++i){ + scanf("%lf%lf%lf%lf", &x1, &y1, &x2, &y2); + arr[i].left = getX(x1, y1); + arr[i].right = getX(x2, y2); + if(arr[i].left > arr[i].right) swap(arr[i].left, arr[i].right); + } + sort(arr, arr + n, cmp); + ans = 1; + flag = arr[0].right; + for(int i = 1; i < n; ++i){ + if(flag < arr[i].left){ + ++ans; + flag = arr[i].right; + }else if(flag < arr[i].right) flag = arr[i].right; + } + if(!n) printf("1\n"); + else printf("%d\n", ans + 1); + } + return 0; +} diff --git a/HDOJ/1688_autoAC.cpp b/HDOJ/1688_autoAC.cpp new file mode 100644 index 0000000..559c4ea --- /dev/null +++ b/HDOJ/1688_autoAC.cpp @@ -0,0 +1,92 @@ +#include +#include +#include +#include +using namespace std; +const int N = 1001; +struct node +{ + int v,w; + node(){} + node(int v,int w):v(v),w(w){} +}; +vector g[N]; +int n,dist[N][2],cnt[N][2]; +bool vis[N][2]; +void Dijkstra(int s) +{ + for(int i=1;i<=n;i++) + { + dist[i][0]=INT_MAX; + dist[i][1]=INT_MAX; + } + memset(vis,false,sizeof(vis)); + dist[s][0]=0; + cnt[s][0]=1; + for(int i=0;i<2*n;i++) + { + int temp=INT_MAX,u=-1,k; + for(int j=1;j<=n;j++) + if(!vis[j][0] && dist[j][0]::iterator it=g[u].begin(); + for(;it!=g[u].end();it++) + { + int newdis=dist[u][k]+it->w; + int v=it->v; + if(newdis +#include +#include +#include +#define maxn 10000+1 +using namespace std; +vectormapp[maxn]; +int n,m; +int visit[maxn][2]; +struct stu +{ + int pre; + int now; + int deep; +}; +int bfs(int p) +{ + queueroot; + stu x,y; + x.pre=-1; + x.now=p; + x.deep=0; + root.push(x); + while(root.size()) + { + x=root.front(); + root.pop(); + if(x.now==p&&x.deep>=3&&x.deep%2) return x.deep; + else if(x.now==p&&x.deep!=0) continue; + for(int i=0;i>t; + int casee=1; + while(t--) + { + cin>>n>>m; + for(int i=1;i<=n;i++) mapp[i].clear(); + for(int i=0;i>x>>y; + mapp[x].push_back(y); + mapp[y].push_back(x); + } + int ans=1<<30; + for(int i=1;i<=n;i++) + { + memset(visit,0,sizeof(visit)); + ans=min(ans,bfs(i)); + } + cout<<"Case "< +#include +#include +#include +#include +using namespace std; +const long long INF = 1e18; +const int maxn = 105; +long long map[maxn][maxn]; +long long L1, L2, L3, L4; +long long C1, C2, C3, C4; +int n; +long long cost(long long dis) +{ + if(dis > 0 && dis <= L1)return C1; + if(dis > L1 && dis <= L2)return C2; + if(dis > L2 && dis <= L3)return C3; + if(dis > L3 && dis <= L4)return C4; + return INF; +} +void floyd() +{ + int i, j, k; + for(k=1; k<=n; k++) + for(i=1; i<=n; i++) + for(j=1; j<=n; j++) + { + if(map[i][j] > map[i][k] + map[k][j]) + map[i][j] = map[i][k] + map[k][j]; + } +} +int main() +{ + int ncase, k=1; + cin >> ncase; + while(ncase--) + { + int m, a, b, i, j; + long long f[maxn]={0}; + cin >> L1 >> L2 >> L3 >> L4; + cin >> C1 >> C2 >> C3 >> C4; + cin >> n >> m; + for(i=1; i<=n; i++) + for(j=1; j<=n; j++) + map[i][j] = INF; + for(i=1; i<=n; i++) + cin >> f[i]; + for(i=1; i> a >> b; + if(map[a][b] != INF) + cout <<"The minimum cost between station "<< a <<" and station "<< b <<" is "<< map[a][b] <<"."< +#include +#include +#include +#include +int map[20][20]; +int Kinga,Kingb; +int Kingc,Kingd; +int abs(int a){return a>0?a:-a;} +int KingFaceToFace() +{ + int i; + if(Kingb==20||Kingd==20)return 0; + if(Kingb==Kingd) + { + for(i=Kingc+1;i6||c<8||d<4||d>6)) + return 0; + if(map[a][b]==8&&(a>3||b<4||b>6||c>3||d<4||d>6)) + return 0; + if(map[a][b]==1){ + Kinga=c; + Kingb=d; + } + if(map[a][b]==8){ + Kingc=c; + Kingd=d; + } + map[c][d]=map[a][b]; + map[a][b]=0; + if(KingFaceToFace()) + return 0; + return 1; +} +int Mandarins(int a,int b,int c,int d) +{ + if(abs(a-c)!=1||abs(b-d)!=1)return 0; + if(map[a][b]==2&&(c<8||c>10||d<4||d>6)) + return 0; + if(map[a][b]==9&&(c>3||c<1||d<4||d>6)) + return 0; + map[c][d]=map[a][b]; + map[a][b]=0; + if(KingFaceToFace()) + return 0; + return 1; +} +int Elephants(int a,int b,int c,int d) +{ + if(abs(a-c)!=2||abs(b-d)!=2)return 0; + if(map[a][b]==3&&(!(((a==6||a==10)&&(b==3||b==7))||(a==8&&(b==1||b==5||b==9)))||!(((c==6||c==10)&&(d==3||d==7))||(c==8&&(d==1||d==5||d==9)))))return 0; + if(map[a][b]==10&&(!(((a==5||a==1)&&(b==3||b==7))||(a==3&&(b==1||b==5||b==9)))||!(((c==5||c==1)&&(d==3||d==7))||(c==3&&(d==1||d==5||d==9)))))return 0; + int x,y; + x=(a+c)/2; + y=(b+d)/2; + if(map[x][y]) + return 0; + map[c][d]=map[a][b]; + map[a][b]=0; + if(KingFaceToFace()) + return 0; + return 1; +} +int Knights(int a,int b,int c,int d) +{ + int luoma[8][2]={{2,1},{2,-1},{-2,1},{-2,-1},{1,2},{1,-2},{-1,2},{-1,-2}}; + int majiao[8][2]={{1,0},{1,0},{-1,0},{-1,0},{0,1},{0,-1},{0,1},{0,-1}}; + int i; + for(i=0;i<8;i++) + { + if(a+luoma[i][0]==c&&b+luoma[i][1]==d) + { + if(map[a+majiao[i][0]][b+majiao[i][1]]) + return 0; + break; + } + } + if(i==8)return 0; + if(map[c][d]==1)Kinga=Kingb=20; + if(map[c][d]==8)Kingc=Kingd=20; + map[c][d]=map[a][b]; + map[a][b]=0; + if(KingFaceToFace()) + return 0; + return 1; +} +int Rooks(int a,int b,int c,int d) +{ + int i; + if(a!=c&&b!=d)return 0; + if(a==c&&d>b) + for(i=b+1;id;i--) + if(map[a][i]) + return 0; + if(b==d&&a>c) + for(i=a-1;i>c;i--) + if(map[i][b]) + return 0; + if(b==d&&ab) + { + for(i=b+1;i1||(cnt==1&&map[c][d]==0)||(cnt==0&&map[c][d]))return 0; + } + if(a==c&&dd;i--) + if(map[a][i]!=0) + cnt++; + if(cnt>1||(cnt==1&&map[c][d]==0)||(cnt==0&&map[c][d]))return 0; + } + if(b==d&&a>c) + { + for(i=a-1;i>c;i--) + if(map[i][b]!=0) + cnt++; + if(cnt>1||(cnt==1&&map[c][d]==0)||(cnt==0&&map[c][d]))return 0; + } + if(b==d&&a1||(cnt==1&&map[c][d]==0)||(cnt==0&&map[c][d]))return 0; + } + if(map[c][d]==1)Kinga=Kingb=20; + if(map[c][d]==8)Kingc=Kingd=20; + map[c][d]=map[a][b]; + map[a][b]=0; + if(KingFaceToFace()) + return 0; + return 1; +} +int Pawns(int a,int b,int c,int d) +{ + if(abs(a-c)+abs(b-d)!=1)return 0; + if(map[a][b]==14&&a<=5) + if(c-a!=1||b!=d) + return 0; + if(map[a][b]==7&&a>=6) + if(c-a!=-1||b!=d) + return 0; + if(map[a][b]==14&&a>5) + if(c-a==-1) + return 0; + if(map[a][b]==7&&a<6) + if(c-a==1) + return 0; + if(map[c][d]==1)Kinga=Kingb=20; + if(map[c][d]==8)Kingc=Kingd=20; + map[c][d]=map[a][b]; + map[a][b]=0; + if(KingFaceToFace()) + return 0; + return 1; +} +int move(int a,int b,int c,int d,int k) +{ + if(map[a][b]<=k*7||map[a][b]>k*7+7) + return 0; + if(a>10||b>9||c>10||d>9||a<1||b<1||c<1||d<1)return 0; + if(map[a][b]==0)return 0; + if((map[a][b]==1||map[a][b]==2||map[a][b]==3||map[a][b]==4||map[a][b]==5||map[a][b]==6||map[a][b]==7)&&(map[c][d]==1||map[c][d]==2||map[c][d]==3||map[c][d]==4||map[c][d]==5||map[c][d]==6||map[c][d]==7)) + return 0; + if((map[a][b]==8||map[a][b]==9||map[a][b]==10||map[a][b]==11||map[a][b]==12||map[a][b]==13||map[a][b]==14)&&(map[c][d]==8||map[c][d]==9||map[c][d]==10||map[c][d]==11||map[c][d]==12||map[c][d]==13||map[c][d]==14)) + return 0; + if(map[a][b]==1||map[a][b]==8) + return King(a,b,c,d); + if(map[a][b]==2||map[a][b]==9) + return Mandarins(a,b,c,d); + if(map[a][b]==3||map[a][b]==10) + return Elephants(a,b,c,d); + if(map[a][b]==4||map[a][b]==11) + return Knights(a,b,c,d); + if(map[a][b]==5||map[a][b]==12) + return Rooks(a,b,c,d); + if(map[a][b]==6||map[a][b]==13) + return Cannons(a,b,c,d); + if(map[a][b]==7||map[a][b]==14) + return Pawns(a,b,c,d); +} +int main() +{ + int t; + int n,k; + int a,b,c,d; + int i,j; + int nCase=1; + int step; + scanf("%d",&t); + while(t--) + { + for(i=1;i<=10;i++) + { + for(j=1;j<=9;j++) + { + scanf("%d",&map[i][j]); + if(map[i][j]==1){ + Kinga=i; + Kingb=j; + } + if(map[i][j]==8){ + Kingc=i; + Kingd=j; + } + } + } + scanf("%d%d",&n,&k); + step=0; + for(i=1;i<=n;i++) + { + scanf("%d%d%d%d",&a,&b,&c,&d); + if(!step) + { + if(!move(a,b,c,d,k)) + step=i; + if(i!=n&&(Kingb==20||Kingd==20)) + step=i+1; + } + k=!k; + } + printf("Case %d: ",nCase++); + if(!step) + printf("Legal move\n"); + else + printf("Illegal move on step %d\n",step); + } + return 0; +} diff --git a/HDOJ/1692_autoAC.cpp b/HDOJ/1692_autoAC.cpp new file mode 100644 index 0000000..3fc8bb5 --- /dev/null +++ b/HDOJ/1692_autoAC.cpp @@ -0,0 +1,34 @@ +#include +using namespace std; +int w[100005],L[100005],p[100005]; +int main() +{ + int T,i,N,j,max,k,sum,carry; + cin>>T; + for(i=1;i<=T;i++) + { + cin>>N; + for(j=1;j<=N;j++) + cin>>w[j]>>L[j]>>p[j]; + max=p[N]; + for(j=1;jmax) + break; + } + if(sum +#include +int tree[13][13]; +long long int dp[13][13][1<<13]; +int main() +{ + int t; + scanf("%d",&t); + for(int p=1;p<=t;p++) + { + int n,m; + scanf("%d%d",&n,&m); + for(int i=1;i<=n;i++) + { + for(int j=1;j<=m;j++) + { + scanf("%d",&tree[i][j]); + } + } + memset(dp,0,sizeof(dp)); + dp[0][m][0]=1; + for(int i=1;i<=n;i++) + { + for(int k=0;k<(1<<(m+1));k++) + { + dp[i][0][k<<1]=dp[i-1][m][k]; + } + for(int j=1;j<=m;j++) + { + int x=1< +#define G1 100005 +int mu[G1]; +void getMu(){ + for(int i=1;it2){ + temp=t1; + t1=t2; + t2=temp; + } + ans1=ans2=0; + for(int i=1;i<=t1;i++) + ans1+=(long long)mu[i]*(t1/i)*(t2/i); + for(int i=1;i<=t1;i++) + ans2+=(long long)mu[i]*(t1/i)*(t1/i); + printf("Case %d: %I64d\n",kase++,ans1-ans2/2); + } + return 0; +} diff --git a/HDOJ/1698_autoAC.cpp b/HDOJ/1698_autoAC.cpp new file mode 100644 index 0000000..ab22b86 --- /dev/null +++ b/HDOJ/1698_autoAC.cpp @@ -0,0 +1,28 @@ +#include +const int n = 1000005; +int map[n][3]; +int main() +{ + int i,M,z,N,sum,v; + scanf("%d",&N); + for(i=1; i<=N; i++) + { + sum = 0; + int Q,j; + scanf("%d%d",&M,&Q); + for(j=1; j<=Q; j++) + scanf("%d%d%d",&map[j][0],&map[j][1],&map[j][2]); + for(j=1; j<=M; j++) + { + v = 1; + for(int k=Q; k>=0; k--) + if(map[k][0]<=j && j<=map[k][1]) + { + v = map[k][2]; + break; + } + sum += v; + } + printf("Case %d: The total value of the hook is %d.\n",i,sum); + } +}