染色

链接：https://ac.nowcoder.com/acm/contest/176/A
来源：牛客网

时间限制：C/C++ 1秒，其他语言2秒
空间限制：C/C++ 524288K，其他语言1048576K
64bit IO Format: %lld

题目描述

fizzydavid和leo有n个方格排成一排，每个方格初始是白色。fizzydavid有红色染料，leo有蓝色染料。他们共进行了m次操作，在每次操作中，fizzydavid或者leo会选择若干个（可以是零个）连续相邻的方格并用自己的染料给这些格子染色。当一个格子被染成某个颜色时，这种染料会覆盖之前这个格子上的颜色。

现在你并不知道他们每次操作选择了哪些格子，只知道每次操作是谁进行的，以及最终这n个方格的颜色。你需要判断是否存在某种选择格子的方式使得操作完之后n个方格的颜色与给定的相同。你还发现，n个格子最终都不是白色。

输入描述:

  1. 第一行包含一个整数T，表示本组数据共有T组测试点。
  2.  
  3. 对每组测试点的第一行是一个由R和B组成的字符串s表示最终格子的颜色。R表示红色，B表示蓝色，同时字符串的长度为n。
  4.  
  5. 第二行是一个由F和L组成的字符串t表示m次操作，F表示某次是fizzydavid操作，L表示是leo操作，同时字符串的长度为m。
  6.  
  7. 所有数据满足T<=20。
  8.  
  9. 50%的数据满足n,m<=15
  10.  
  11. 80%的数据满足n,m<=100
  12.  
  13. 100%的数据满足n,m<=100000

输出描述:

  1. 对每组测试点输出一行，如果满足条件输出Yes否则输出No。

输入例子:
  1. 3
  2. R
  3. FL
  4. RRRBR
  5. FFFF
  6. BRRBBRB
  7. LFL
输出例子:
  1. Yes
  2. No
  3. Yes

-->

示例1

输入

复制

  1. 3
  2. R
  3. FL
  4. RRRBR
  5. FFFF
  6. BRRBBRB
  7. LFL

输出

复制

  1. Yes
  2. No
  3. Yes

说明

  1. 对第一个测试点，第二次操作可以是空的。
  2.  
  3. 对第二个测试点，s中有B，但是t中没有L，因此不合法。
  4.  
  5. 对第三个测试点，BBBBBBB -> BRRRRRB -> BRRBBRB就是合法的。
  1. /*
  2. 正序涂色比较难操作，因为一个格子可以被染很多次。可以考虑倒序涂色
  3. 会发现每个格子最多会被染色一次。
  4. 因为后面的染色会覆盖前面的染色。
  5. 所以可以染完色后把格子删掉。然后合并删掉两边的同色格子。
  6. 考虑贪心
  7. 1.一定会删除尽量多的连续格子 2.一定会优先删中间的格子(删两边没有合并)。
  8.  
  9. 具体实现不必直接操作。只需要统计每个连续的同色的区域个数然后每次做减法就好。
  10. 最优操作和不优的操作在这里不会体现出来，这样可以默认是最优操作。
  11. */
  12. #include<bits/stdc++.h>
  13.  
  14. #define N 100007
  15.  
  16. using namespace std;
  17. int n,m,T;
  18. char a[N],opt[N];
  19.  
  20. int main()
  21. {
  22.     scanf("%d",&T);
  23.     while(T--)
  24.     {
  25.         scanf("%s",a+);scanf("%s",opt+);
  26.         n=strlen(a+);m=strlen(opt+);
  27.         int r=,b=;
  28.         for(int i=; i<=n; i++)
  29.         {
  30.             if(a[i]!=a[i-])
  31.             {
  32.                 if(a[i]=='R') r++;
  33.                 else b++;
  34.             }
  35.         }
  36.         for(int i=m; i>=; i--)
  37.         {
  38.             if(opt[i]=='F')
  39.             {
  40.                 r--;if(b>=) b--;
  41.             }
  42.             else
  43.             {
  44.                 b--;
  45.                 if(r>=) r--;
  46.             }
  47.         }
  48.         if(r<=&&b<=) puts("Yes");
  49.         else puts("No");
  50.     }
  51.     return ;
  52. }

链接：https://ac.nowcoder.com/acm/contest/176/B
来源：牛客网

推箱子

时间限制：C/C++ 2秒，其他语言4秒
空间限制：C/C++ 524288K，其他语言1048576K
64bit IO Format: %lld

题目描述

在平面上有n个箱子，每个箱子都可以看成一个矩形，两条边都和坐标轴平行。任何两个矩形都不相交，但可能有某个点或某条边重合。约定x轴正方向为右，y轴正方向为上。

现在Fizzydavid要推这些箱子。他会选择某个箱子开始，并以每秒1个单位的速度使这个箱子向右移动。如果路上正面碰上某个箱子，被碰上的箱子会在碰到的那个瞬间开始进入运动状态，以1个单位的速度向右移动，不会转动或改变运动方向。

准确地说，在某个时刻一个箱子i处于移动状态当且仅当：i是选择的箱子；或者存在一个处于移动状态的箱子j，它的右边界等于箱子i的左边界，且它们在y轴上的投影的公共长度>0。你可以发现在这种情况下，任意时刻每个矩形仍然不相交。

Fizzydavid告诉了你所有的信息，需要你求出k秒后每个矩形的位置。

输入描述:

第一行两个整数n,t和k。Fizzydavid开始选择的是输入的第t个矩形。

接下来n行每行四个整数x1,i,y1,i,x2,i,y2,i，表示矩形的左下角坐标是(x1,i,y1,i)，右上角坐标是(x2,i,y2,i)。

对于30%的数据，k<=100。

对于另外40%的数据，n<=1000。

对于所有的数据，n<=105，1<=t<=n，1<=k<=109，所有坐标都在-109和109之间。保证任意两个矩形不相交。

输出描述:

  1. 输出一行n个整数，第i个整数表示k秒后第i个矩形的左下角的x坐标。你可以发现只要知道这个值就能唯一确定矩形的位置。

输入例子:
  1. 3 1 5
  2. 0 0 1 1
  3. 1 0 2 1
  4. 4 0 5 1
输出例子:
  1. 5 6 7

-->

示例1

输入

复制

  1. 3 1 5
  2. 0 0 1 1
  3. 1 0 2 1
  4. 4 0 5 1

输出

复制

  1. 5 6 7

说明

  1. 在刚开始时，前两个矩形就处于移动状态。在第二秒开始时，第三个矩形进入移动状态。
  1. /*
  2. copy
  3. 发现矩形之间可以连边
  4. 可以转化为类似最短路的问题。
  5. 但只能过40
  6. 发现有序处理矩形是不严格n^2的，竟然跑过70...
  7. */
  8. #include<bits/stdc++.h>
  9. #define int long long
  10. #define inf 66666666666ll
  11. #define max(a,b) (a>b?a:b)
  12. using namespace std;
  13. int n,t,k;
  14. struct node
  15. {
  16.     long long x1,y1,x2,y2;
  17.     int pos;
  18.     bool operator <(const node a)const
  19.     {
  20.         if(x1!=a.x1) return x1<a.x1;
  21.         return y1<a.y1;
  22.     }
  23. } num[];
  24. int tim[];
  25. long long answer[];
  26. inline long long min(long long a,long long b)
  27. {
  28.     return a<b?a:b;
  29. }
  30. signed main()
  31. {
  32.     scanf("%lld%lld%lld",&n,&t,&k);
  33.     for(int i=; i<=n; i++) scanf("%lld%lld%lld%lld",&num[i].x1,&num[i].y1,&num[i].x2,&num[i].y2),num[i].pos=i;
  34.     sort(num+,num+n+);
  35.     for(int i=; i<=n; i++) tim[i]=inf;
  36.     int start=;
  37.     while(num[start].pos!=t && start<=n) start++;
  38.     tim[start]=;
  39.     for(int i=start+; i<=n; i++)
  40.     {
  41.         int ans=inf;
  42.         for(int j=start; j<i; j++)
  43.         {
  44.             if((num[j].y1>=num[i].y1 && num[j].y1<num[i].y2) || (num[j].y1<=num[i].y1 && num[j].y2>num[i].y1))
  45.                 ans=min(ans,tim[j]+num[i].x1-num[j].x2);
  46.         }
  47.         tim[i]=ans;
  48.         if(ans<inf && ans>k) break;
  49.     }
  50.     for(int i=; i<=n; i++) answer[num[i].pos]=num[i].x1+max(k-tim[i],);
  51.     for(int i=; i<=n; i++)
  52.         printf("%lld ",answer[i]);
  53. }

70暴力

  1. /*
  2. 正解有地方不太懂
  3. 时间比较紧了就这样吧...
  4. */
  5. #include<bits/stdc++.h>
  6.  
  7. #define N 100007
  8.  
  9. #define ls cur<<1
  10. #define rs cur<<1|1
  11.  
  12. using namespace std;
  13. int n,t,k,a[N],num,pre[N],ans[N];
  14. struct qwq{
  15.     int x1,y1,x2,y2,id;
  16.     bool operator <(const qwq &x) const{
  17.         return x1<x.x1||(x1==x.x1&&y1<x.y1);
  18.     }
  19. } m[N];
  20. struct Node{
  21.     int mx,lazy;
  22. } tr[N<<];
  23.  
  24. inline void pushup(int cur)
  25. {
  26.     tr[cur].mx=max(tr[ls].mx,tr[rs].mx);
  27. }
  28.  
  29. inline void pushdown(int cur)
  30. {
  31.     if(tr[cur].lazy!=-)
  32.     {
  33.         tr[ls].mx=tr[cur].lazy,tr[rs].mx=tr[cur].lazy;
  34.         tr[ls].lazy=tr[rs].lazy=tr[cur].lazy;
  35.         tr[cur].lazy=-;
  36.     }
  37. }
  38.  
  39. inline void update(int cur,int l,int r,int L,int R,int c)
  40. {
  41.     if(L<=l && r<=R)
  42.     {
  43.         tr[cur].lazy=tr[cur].mx=c;
  44.         return;
  45.     }
  46.     pushdown(cur);
  47.     int mid=(l+r)>>;
  48.     if(L<=mid) update(ls,l,mid,L,R,c);
  49.     if(mid<R) update(rs,mid+,r,L,R,c);
  50.     pushup(cur);
  51. }
  52.  
  53. inline int query(int cur,int l,int r,int L,int R)
  54. {
  55.     if(L<=l && r<=R) return tr[cur].mx;
  56.     pushdown(cur);
  57.     int mid=(l+r)>>,res=;
  58.     if(L<=mid) res=max(res,query(ls,l,mid,L,R));
  59.     if(mid<R) res=max(res,query(rs,mid+,r,L,R));
  60.     return res;
  61. }
  62.  
  63. int main()
  64. {
  65.     scanf("%d%d%d",&n,&t,&k);
  66.     for(int i=; i<=n; i++)
  67.     {
  68.         scanf("%d%d%d%d",&m[i].x1,&m[i].y1,&m[i].x2,&m[i].y2);
  69.         m[i].id=i;
  70.         a[++num]=m[i].y1; a[++num]=m[i].y2;
  71.     }
  72.     sort(a+,a+num+);
  73.     num=unique(a+,a+num+)-a-;
  74.     sort(m+,m+n+);
  75.     for(int i=; i<=n; i++)
  76.     {
  77.         ans[m[i].id]=m[i].x1;
  78.         if(m[i].id==t)
  79.         {
  80.             int x=lower_bound(a+,a+num+,m[i].y1)-a;
  81.             int y=lower_bound(a+,a+num+,m[i].y2)-a;
  82.             update(,,num,x,y,m[i].x2-m[i].x1);
  83.             t=i;
  84.             break;
  85.         }
  86.     }
  87.     k+=m[t].x1;
  88.     ans[m[t].id]=k;
  89.     for(int i=t+; i<=n; i++)
  90.     {
  91.         int x=lower_bound(a+,a+num+,m[i].y1)-a;
  92.         int y=lower_bound(a+,a+num+,m[i].y2)-a;
  93.         int pre=query(,,num,x,y);
  94.         if(!pre || pre+k<=m[i].x1) ans[m[i].id]=m[i].x1;
  95.         else
  96.         {
  97.             ans[m[i].id]=k+pre;
  98.             update(,,num,x,y,m[i].x2-m[i].x1+pre);
  99.         }
  100.     }
  101.     for(int i=;i<=n;i++) printf("%d ",ans[i]);
  102.     return ;
  103. }

链接：https://ac.nowcoder.com/acm/contest/176/C
来源：牛客网

Revue

时间限制：C/C++ 1秒，其他语言2秒
空间限制：C/C++ 524288K，其他语言1048576K
64bit IO Format: %lld

题目描述

梦想的revue拉开帷幕，你需要和你的对手争夺position zero。revue的形式是一个游戏，游戏中有一排共n个位置可以争夺，每个位置有一个权值，第i个位置的权值为ai。游戏是回合制的，你和你的对手轮流进行操作，你是先手。每一回合，进行操作的玩家需要在这一排位置的两端一共标记K个位置，一个位置最多只能被标记一次，操作必须保证每时每刻未被标记的位置是连续的。最终剩下的一个未标记的位置的权值就是游戏的得分，你需要使这个得分最大，你的对手需要使这个得分最少。保证最后只剩下一个位置未被标记，即n-1是K的倍数。若你和你的对手都使用最优策略进行操作，请问这个游戏的最终得分是多少。

输入描述:

  1. 本题有多组测试数据。第一行一个整数T表示测试数据组数。接下来分别是T组数据。每组数据内：
为了避免输入过慢，输入数据分为两种。若第一行为raw，则表示这组数据是输入给定的。第二行会有两个整数n和K。第三行有n个整数，第i个数表示ai。若第一行为random，则表示这组数据是随机生成的。第二行会有4个整数n，K，S，P。表示a1=S, ai= (2333ai-1+6666) mod P。（mod表示取模操作）
20%的数据 1 ≤ n,K ≤ 10
40%的数据保证 1 ≤ n,K ≤ 1000
另外20%的数据保证 1 ≤ n ≤ 10000, K ≥ 100
80%的数据保证 1 ≤ n,K ≤ 10000
100%的数据保证n-1是K的倍数，0 ≤ T ≤ 100，1 ≤ K < n ≤ 100000，0 ≤ S, P, ai ≤ 109，类型为raw的数据的n的和不超过500000。

输出描述:

  1. 每组数据输出一行表示答案，一共输出T行。

输入例子:
  1. 3
  2. raw
  3. 5 2
  4. 5 3 4 2 1
  5. raw
  6. 7 2
  7. 5 3 4 2 1 6 7
  8. random
  9. 13 3 2 20
输出例子:
  1. 3
  2. 4
  3. 2

-->

示例1

输入

复制

  1. 3
  2. raw
  3. 5 2
  4. 5 3 4 2 1
  5. raw
  6. 7 2
  7. 5 3 4 2 1 6 7
  8. random
  9. 13 3 2 20

输出

复制

  1. 3
  2. 4
  3. 2

说明

  1. 对于样例中第一个测试数据，初始有5个位置未标记，他们的权值是：
  2.  
  3. 5 3 4 2 1
  4.  
  5. 第一回合，最优策略下你选择标记右端的两个位置（即第4个位置和第5个位置），剩下来未被标记的位置的权值为：
  6.  
  7. 5 3 4
  8.  
  9. 第二回合，最优策略下你的对手选择标记左端的一个位置和右端的一个位置（即第1个位置和第3个位置），剩下来未被标记的位置的权值为：
  10.  
  11. 3
  12.  
  13. 这个游戏的最终得分为3。注意当你和你的对手都是用最优策略进行操作时，游戏最终的得分是唯一的。
  1. #include<bits/stdc++.h>
  2.  
  3. #define N 5001
  4. #define M 100007
  5. #define ll long long
  6. #define inf 0x3f3f3f3f
  7.  
  8. using namespace std;
  9. ll n,m,k,s,p,ans,cnt,T;
  10. ll f[N][N],a[M],sum[M];
  11. bool opt;
  12.  
  13. inline int read()
  14. {
  15.     int x=,f=;char c=getchar();
  16.     while(c>''||c<''){if(c=='-')f=-;c=getchar();}
  17.     while(c>=''&&c<=''){x=x*+c-'';c=getchar();}
  18.     return x*f;
  19. }
  20.  
  21. ll min(ll a,ll b){return a<b?a:b;}
  22.  
  23. void solve1()
  24. {
  25.         for(int i=;i<=n;i++) for(int j=;j<=n;j++) f[i][j]=-;
  26.         for(int i=;i<=n;i++) f[i][i]=a[i];
  27.         if(((n-)/k)%==) opt=;
  28.         else opt=;
  29.  
  30.         for(int L=k;L<n;L+=k)
  31.         {
  32.             if(L%k!=) continue;
  33.             opt^=;
  34.             for(int i=;i+L<=n;i++)
  35.             {
  36.                 int j=i+L;ll res1=inf,res2=;
  37.                 res1=min(res1,f[i+k][j]); res2=max(res2,f[i+k][j]);
  38.                 res1=min(res1,f[i][j-k]); res2=max(res2,f[i][j-k]);
  39.                 for(int x=;x<k;x++)
  40.                 {
  41.                     if(i+x>j-k+x) break;
  42.                     if(i+x>n || j-k+x<) continue;
  43.                     if(f[i+x][j-k+x]==-) continue;
  44.                     res1=min(res1,f[i+x][j-k+x]); res2=max(res2,f[i+x][j-k+x]);
  45.                 }
  46.                 if(opt) f[i][j]=res1;
  47.                 else f[i][j]=res2;
  48.             }
  49.         }
  50.         ans=max(ans,f[][n]);
  51. }
  52.  
  53. int main()
  54. {
  55.     freopen("data.txt","r",stdin);
  56.     freopen("2.out","w",stdout);
  57.     cin>>T;
  58.     while(T--)
  59.     {
  60.         ans=;
  61.         char ch[];scanf("%s",ch);
  62.         if(ch[]=='w')
  63.         {
  64.             n=read();k=read();
  65.             for(int i=;i<=n;i++) a[i]=read();
  66.         }
  67.         else
  68.         {
  69.             n=read();k=read();a[]=s=read();p=read();
  70.             for(int i=;i<=n;i++) a[i]=((*a[i-])%p+)%p;
  71.         }
  72.         if(n<= && k<=)
  73.         {
  74.             solve1();//solve2();
  75.         }
  76.         //else solve2();
  77.         cout<<ans<<endl;
  78.     }
  79.     return ;
  80. }
  81. /*
  82. 1
  83. raw
  84. 7 2
  85. 1 1 9 2 2 2 2
  86.  
  87. ans=9
  88. */

40暴力

  1. /*
  2. 60暴力
  3. 改变一下40暴力dp状态，定义f[i]为以i开头的长度为x*k+1的dp值
  4. 这样f[i]就可以对每次操作用单调队列维护答案了。
  5. */
  6. #include<bits/stdc++.h> 
  7.  
  8. #define N 100007
  9. #define ll long long
  10.  
  11. char ch[];
  12. int T,n,k,Tim,head,tail,S,P;
  13. ll num[N],Q[N];;
  14.  
  15. ll Nxt(ll v){return (2333LL*v+6666LL)%P;}
  16.  
  17. bool cmp(ll a, ll b, int d)
  18. {
  19.     if(d) return a<=b;
  20.     return a>=b;
  21. }
  22.  
  23. int main()
  24. {
  25.     scanf("%d",&T);
  26.     while(T--)
  27.     {
  28.         scanf("%s",ch);
  29.         if(ch[]=='w')
  30.         {
  31.             scanf("%d%d",&n,&k);
  32.             for(int i=;i<=n;++i) scanf("%lld", &num[i]);
  33.         }
  34.         else
  35.         {
  36.             scanf("%d%d%lld%lld",&n,&k,&S,&P);
  37.             num[]=S;
  38.             for(int i=;i<=n;++i)   num[i]=Nxt(num[i-]);
  39.         }
  40.         Tim=(n-)/k;
  41.         for(int t=,d=Tim&;t<=Tim;++t,d=!d)
  42.         {
  43.             head=tail=;
  44.             memset(Q,,sizeof Q);
  45.             for(int i=,q=-k;i<=n;++i,++q)
  46.             {
  47.                 while(head<tail && Q[head]<q) ++head;
  48.                 while(head<tail && cmp(num[Q[tail-]], num[i], d))   --tail;
  49.                 Q[tail++]=i;
  50.                 if(q>)  num[q]=num[Q[head]];
  51.             }
  52.             n-=k;
  53.         }
  54.         printf("%lld\n",num[]);
  55.     }
  56.     return ;
  57. }
  1.  

牛客网NOIP赛前集训营-提高组（第八场）的更多相关文章

  1. 牛客网NOIP赛前集训营-普及组（第二场）和 牛客网NOIP赛前集训营-提高组（第二场）解题报告

    目录 牛客网NOIP赛前集训营-普及组(第二场) A 你好诶加币 B 最后一次 C 选择颜色 D 合法括号序列 牛客网NOIP赛前集训营-提高组(第二场) A 方差 B 分糖果 C 集合划分 牛客网N ...

  2. 牛客网NOIP赛前集训营-提高组（第二场）A 方差

    链接:https://www.nowcoder.com/acm/contest/173/A来源:牛客网 题目描述 一个长度为 m 的序列 b[1...m] ,我们定义它的方差为 ,其中  表示序列的平 ...

  3. [牛客网NOIP赛前集训营-提高组（第一场）]C.保护

    链接:https://www.nowcoder.com/acm/contest/172/C来源:牛客网 题目描述 C国有n个城市,城市间通过一个树形结构形成一个连通图.城市编号为1到n,其中1号城市为 ...

  4. 牛客网NOIP赛前集训营-提高组（第一场）

    牛客的这场比赛感觉真心不错!! 打得还是很过瘾的.水平也比较适合. T1:中位数: 题目描述 小N得到了一个非常神奇的序列A.这个序列长度为N,下标从1开始.A的一个子区间对应一个序列,可以由数对[l ...

  5. 比赛总结——牛客网 NOIP赛前集训营提高组模拟第一场

    第一场打的很惨淡啊 t1二分+前缀最小值没想出来,20分的暴力也挂了,只有10分 t2数位dp,调了半天,结果因为忘了判0的特殊情况WA了一个点,亏死 t3emmmm.. 不会 imone说是DSU ...

  6. 牛客网NOIP赛前集训营-提高组（第一场）B 数数字

    数数字 思路: 数位dp 代码: #pragma GCC optimize(2) #pragma GCC optimize(3) #pragma GCC optimize(4) #include< ...

  7. 牛客网NOIP赛前集训营-提高组（第一场）A 中位数

    中位数 思路: 二分答案 代码: #pragma GCC optimize(2) #pragma GCC optimize(3) #pragma GCC optimize(4) #include< ...

  8. 牛客网NOIP赛前集训营 提高组 第5场 T2 旅游

    [题解] 我们可以发现不在最小生成树上的边一定不能多次经过,因为一条不在最小生成树上的边(u,v)的边权比最小生成树上(u,v)之间的路径更长,选择不在最小生成树上的边一定不划算. 我们还需要确定最小 ...

  9. 牛客网NOIP赛前集训营-提高组（第四场）游记

    牛客网NOIP赛前集训营-提高组(第四场)游记 动态点分治 题目大意: \(T(t\le10000)\)组询问,求\([l,r]\)中\(k(l,r,k<2^{63})\)的非负整数次幂的数的个 ...

  10. 牛客网NOIP赛前集训营-提高组（第四场）B区间

    牛客网NOIP赛前集训营-提高组(第四场)B区间 题目描述 给出一个序列$ a_1  \dots   a_n$. 定义一个区间 \([l,r]\) 是好的,当且仅当这个区间中存在一个 \(i\),使得 ...

随机推荐

  1. java构造方法的特点和理解--三只坚果

    构造方法的特点:1.首先构造方法是基于类,名字必须与类的名字完全相同(构造方法一般是自己编写的类需要初始化)2.每个类都有一个默认的构造方法,既无参数又无返回值,其作用是使用new操作符创建新对象后初 ...

  2. INFO org.apache.hadoop.ipc.RPC: Server at master/192.168.200.128:9000 not available yet, Zzzzz...

    hadoop 启动时namenode和datanode可以启动,使用jps命令也可以看到进程,但是在浏览器中输入master:50070却没有显示datanode 查看datanode的log日志: ...

  3. css实现文字渐变

    css文件渐变虽然兼容性比较差,但是用在移动端和chrome中还是没有问题的. 实现文件渐变的方法有两种 1. 使用 background 的属性 2. 使用 mask 属性 方式一. <!DO ...

  4. jmeter的jmx脚本结构解析

    jmeter的jmx脚本是xml文档,简单分析下其结构 xml是树形结构:jmeter界面的树形结构就是xml的结构 一级目录: 二级目录:在一级目录右键后可以看到的,都可以做为二级目录 三级目录.n ...

  5. Nginx在Linux下的安装部署

    Nginx简单介绍 Nginx ("engine x") 是一个高性能的 HTTP 和 反向代理 server,也是一个 IMAP/POP3/SMTP server.Nginx作为 ...

  6. c# 自定义Base16编码解码

               一.自定义Base16编码原理                  Base16编码跟Base64编码原理上有点不同,当然前面转换是一样的,都是是将输入的字符串根据默认编码转换成一 ...

  7. Python中暂未解决的问题

    编写一个复杂的计算器,可以在通过GUI输出出来.参考代码http://www.cnblogs.com/BeginMan/p/3216093.html shelve模块中open()函数调用文件文件的路 ...

  8. Codeforces Round #316 (Div. 2) C. Replacement

    题意:给定一个字符串,里面有各种小写字母和' . ' ,无论是什么字母,都是一样的,假设遇到' . . ' ,就要合并成一个' .',有m个询问,每次都在字符串某个位置上将原来的字符改成题目给的字符, ...

  9. URL编码总结

    URL编码总结           URL是Universal Resource Locator的简称.翻译过来那就是统一资源定位符,好吧,我们常常会俗称为网页地址. 一个URL的格式一般是这种:协议 ...

  10. 排队理论之性能分析 - Little Law &amp; Utilization Law

    了解一个系统的性能一般是參考一些度量值(Metric),而怎样计算出这些Metric就是我们要讨论的.Little Law(排队理论:利特儿法则)和Utilization Law是Performanc ...