HIT Training Camp III

A:http://poj.org/problem?id=1270

POJ 1270Following Orders

Analysis
分析

这是一道比较典型的全排列生成问题，只是生成的每一个排列都要满足给定的条件，且必须按顺序生成。我们当然可以简单的利用STL里的next_permutation函数来解决这个问题，事实上这是非常容易的。关于next_permutation和prev_permutation这两个神奇函数的内部算法，请参见我的另一篇文章：全排列生成算法。
回到本问题的解答，既然已经可以按照题目要求的字母表顺序生成全排列，那么现在的问题就是如何使生成的排列符合给定的约束。最简单的办法就是检查已生成序列中是否存在违背约束的字母对，当然是要用双重循环遍例字符串中的所有字母对。由于最多只有26个字母，因此为加快速度，可以建立一个26×26的二维数组来表示两个字母间是否给定了大于的约束关系。检查生成的排列时，如果发现了某一对字母逆向的符合了这个关系表中对应的结点，则认为是非法的排列。

暴力竟然可过！

#include <algorithm>
#include <iostream>
#include <cstdio>
#include <string.h>
using namespace std;
int main()
{
    int m[27][27];
    char a[50],aa[50],b[1000],bb[1000];
    char ch;
    int flag=0;
    memset(b,0,sizeof(b));
    memset(a,0,sizeof(a));
    memset(aa,0,sizeof(aa));
    memset(bb,0,sizeof(bb));
    while(gets(a))
    {
        if(flag==1)
        printf("\n");
        flag=1;
        int j=0;
        int z=strlen(a);
        for(int i=0; i<z; i++)
        {
            if(a[i]!=' ')
            {
                aa[j++]=a[i];
            }
        }
        gets(b);
        j=0;
        int x=strlen(b);
        for(int i=0; i<x; i++)
        {
            if(b[i]!=' ')
                bb[j++]=b[i];
        }
        memset(m,1,sizeof(m));
        int mm=strlen(bb);
        for(int i=0; i<mm; i+=2)
            m[bb[i+1]-'a'][bb[i]-'a']=0;
        int n=strlen(aa);
        sort(aa,aa+n);
        int ff=1;
        do
        {
            for(int i=0;i<n-1;i++)
            {
                for(int j=i+1;j<n;j++)
                {
                    if(m[aa[i]-'a'][aa[j]-'a']==0)
                    {
                        ff=0;
                        break;
                    }
                }
                if(ff==0)break;
            }
            if(ff==0);
            else
            {
                for(int i=0;i<n;i++)
                printf("%c",aa[i]);
                printf("\n");
            }
            ff=1;
        }
        while (next_permutation(aa,aa+n));
        memset(b,0,sizeof(b));
        memset(a,0,sizeof(a));
        memset(aa,0,sizeof(aa));
        memset(bb,0,sizeof(bb));
    }
}

另附一份大神代码！

#include <algorithm>
#include <iostream>
#include <string>
using namespace std;
//主函数
int main(void) {
    bool bFirst = true;
    char szOrder[24];
    //循环读取并处理每一个组原字符串和约束
    for (string str; getline(cin, str); bFirst = false) {
        //为加快速度，便于处理，将原字符串转存到数组中
        strcpy(szOrder, str.c_str());
        //去掉原字符串中间的空格
        int nLen = remove(szOrder, &szOrder[str.size()], ' ') - szOrder;
        szOrder[nLen] = '\0';
        //获取约束串
        getline(cin, str);
        //去掉约束串中间的空格
        str.erase(remove(str.begin(), str.end(), ' '), str.end());
        //生成约束关系表，如果存在约束i > j，则aCompMat[i][j]为true
        bool aCompMat[26][26] = {0};
        for (string::iterator i = str.begin(); i != str.end(); i += 2) {
            aCompMat[*i - 'a'][*(i + 1) - 'a'] = true;
        }
        //将原字符串从大到小排序，准备生成全排列
        sort(&szOrder[0], &szOrder[nLen]);
        //如果不是第一次，要按要求在第一行输出一个回车
        if (!bFirst) {
            cout << endl;
        }
        //bFlag为false表示发现该顺序不满足约束。每次生成下一组全排列
        for (bool bFlag = true; bFlag; bFlag = next_permutation(
            &szOrder[0], &szOrder[nLen])) {
            //循环判断当前生成的顺序中是否每一对字符都满足约束
            for (int i = 0; i < nLen - 1 && bFlag; ++i) {
                for (int j = i + 1; j < nLen && bFlag; ++j) {
                    //出现逆序，即aCompMat[j][i] = true，即不满足
                    bFlag &= !aCompMat[szOrder[j] - 'a'][szOrder[i] - 'a'];
                }
            }
            //如果全满足约束，则输出有序集
            if (bFlag) {
                cout << szOrder << endl;
            }
        }
    }
    return 0;
}

B:http://poj.org/problem?id=2528   Mayor's posters， 也是HOJ上的题

线段树：

#include<iostream>
#include<algorithm>
#include<cstdio>
>
using namespace 
#include<string.
hstd;
const int MAXN = 20005 ;
tree[MAXN*4
struct NODE
{
  int l,r,c;
}
 
 
 ];
struct L
{
  int li,num;
 
 
r ) const
    {
  return li<r.li;
     
 
    bool operator < ( const L&
     };
};
ine[MAXN];
in
L 
lt post[MAXN][2];
bool vis[MAXN];
int cnt;
ee[v].c=0,tree[v].l=l,tree[v].r=r;
   
void make_tree ( int v, int l, int r )
{
    int mid=(l+r)>>1;
    
t
r if ( l!=r )
    {
  make_tree( v<<1, l, mid );
     
     
    make_tree( (v<<1)+1, mid+1, r );
    }
}
        tree[v].c=c;
        return;
    }
void update ( int v, int l, int r, int c )
{
    int mid;
    if ( tree[v].l==l && tree[v].r==r )
    {
    if ( tree[v].c>0 && tree[v].c!=c )
 r<=m
    {
        tree[v<<1].c=tree[v].c;
        tree[(v<<1)+1].c=tree[v].c;
        tree[v].c=0;
    }
    mid=(tree[v].l+tree[v].r)>>1;
    if 
(id )  update( v<<1, l, r, c );
    else if ( l>mid ) update( (v<<1)+1, l, r, c );
    else
    {
        update( v<<1, l, mid, c );
    {
            vis[tree[v].c]=true;
 
        update( (v<<1)+1, mid+1, r, c );
    }
}

void sum ( int v )
{
    if ( tree[v].c )
    {
        if ( !vis[tree[v].c] )
   
            cnt++;
        }
        return;
    }
    sum( v<<1 );
    sum( (v<<1)+1 );
}

int main ( )
{
    int n,N,i;
    scanf("%d",&N);
    while ( N-- )
    {
ost[i][0],&pos
        cnt=0;
        scanf("%d",&n);
        memset( vis, false, sizeof(vis) );
        //记录端点
        for ( i=0 ; i<n ; i++ )
        {
            scanf("%d%d",&
pt[i][1]);
            line[i<<1].li=post[i][0];
            line[i<<1].num=-(i+1);           //表示起点
            line[(i<<1)+1].li=post[i][1];

        for( i=0; i<2*n; i++ )
        {
         
            line[(i<<1)+1].num=i+1;          //表示终点
        }
        //离散化坐标
        sort( line, line+n*2 );
        int tp=1,temp=line[0].li
;   if( line[i].li!=temp )
            {
                tp++;
                temp=line[i].li;
            }
            if( line[i].num<0 ) post[-line[i].num-1][0]=tp;    //表示起点
 post[i][0], post[i][1], i+1 );
        sum(1);
      
            else  post[line[i].num-1][1]=tp;    //表示终点
        }
        //计算离散化之后不同点的个数，存在tp中
        make_tree( 1, 1, tp );
        for ( i=0 ; i<n ; i++ )
            update( 1
,  printf("%d\n",cnt);
    }
}

D:http://poj.org/problem?id=2505

乘法博弈

http://blog.csdn.net/e6894853/article/details/8220903