2017-2018 ACM-ICPC, NEERC, Southern Subregional Contest (Online Mirror, ACM-ICPC Rules, Teams Prefer

POJ——883

E. Field of Wonders

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<set>
#include<cstring>
using namespace std;
int main() {
    int n;
    char s[52];
    while ( cin >> n >> s ) {
        bool know[26] = {};
        for ( int i = 0; i < n; i++ )
            if ( s[i] != '*' )
                know[s[i] - 97] = true;
        int m, com[26] = {};
        char in[52];
        cin >> m;
        for ( int i = 0; i < m; i++ ) {
            scanf ( "%s", in );
            if ( strlen ( in ) != n ) in[0] = 'A';
            for ( int j = 0; j < n; j++ ) {
                if ( s[j] == '*' && com[in[j] - 97] == i )
                    com[in[j] - 97]++;
                if ( ( s[j] != '*' && s[j] != in[j] ) || ( s[j] == '*' && know[in[j] - 97] ) ) {
                    for ( int k = 0; k < 26; k++ )
                        if ( com[k] == i )
                            com[k]++;
                    break;
                }
            }
        }
        int ans = 0;
        for ( int i = 0; i < 26; i++ )
            if ( com[i] == m && ( !know[i] ) )
                ans++;
        cout << ans << endl;
    }
    return 0;
}

F. Lost in Transliteration

#include<iostream>
#include<algorithm>
#include<string>
#include<set>
using namespace std;
int main() {
    int n;
    while(cin>>n) {
        int ans=0;
        set<string>filter;
        string s;
        while(n--) {
            cin>>s;
            for(int i=0; i<s.size(); i++) {
                if(s[i]=='u') {
                    s[i++]='o';
                    s.insert(i,"o");
                }
                while(i&&s[i]=='h'&&s[i-1]=='k')
                    s.erase(--i,1);
            }
            if(filter.insert(s).second) ans++;
        }
        cout<<ans<<endl;
    }
    return 0;
}

G. Orientation of Edges

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
int n, m, str, place[300001], flag;
struct AP {
    int val, Str, End;
    bool operator < ( const AP &t ) const {
        return Str < t.Str;
    }
} in[600002];
AP func1 ( int val, int Str, int End ) {
    AP t;
    t.val = val;
    t.Str = Str;
    t.End = End;
    return t;
}
void func2() {
    place[in[0].Str] = 0;
    for ( int i = 1; i < m + flag; i++ )
        if ( in[i].Str != in[i - 1].Str )
            place[in[i].Str] = i;
}
char out[300001];
bool com[300001], use[300001];
int func3 ( bool vju ) {
    queue<int>que;
    que.push ( str );
    int ans = 0;
    memset ( com, false, sizeof com );
    memset ( use, false, sizeof use );
    for ( int i = 0; i < flag; i++ )
        out[i] = '+';
    out[flag] = 0;
    com[str] = true;
    while ( !que.empty() ) {
        int temp = que.front();
        que.pop();
        if ( use[temp] ) continue;
        for ( int i = place[temp]; i < m + flag && in[i].Str == temp; i++ )
            if ( vju ) {
                if ( !com[in[i].End] ) {
                    if ( in[i].val < 0 ) out[-in[i].val - 1] = '-';
                    que.push ( in[i].End );
                    com[in[i].End] = true;
                    ans++;
                }
            } else if ( !com[in[i].End] ) {
                if ( in[i].val > 0 ) out[in[i].val - 1] = '-';
                if ( !in[i].val ) {
                    que.push ( in[i].End );
                    com[in[i].End] = true;
                    ans++;
                }
            }
        use[temp] = true;
    }
    return ans + 1;
}
int main() {
    while ( ~scanf ( "%d%d%d", &n, &m, &str ) ) {
        flag = 0;
        for ( int i = 0; i < m; i++ ) {
            scanf ( "%d%d%d", &in[i + flag].val, &in[i + flag].Str, &in[i + flag].End );
            if ( in[i + flag].val - 1 ) {
                in[i + flag ].val =  1 + flag ;
                in[i + flag + 1] = func1 ( - ( ++flag ), in[i + flag ].End, in[i + flag ].Str );
            } else in[i + flag].val--;
        }
        sort ( in, in + m + flag );
        func2();
        printf ( "%d\n%s\n", func3 ( true ), out );
        printf ( "%d\n%s\n", func3 ( false ), out );
    }
    return 0;
}

H. Palindromic Cut

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
char s[400002], out[400002];
int in[125], mid[400002] ;
void func1 ( int n, int place ) {
    for ( int i = 48, flag = 0; flag <= n - flag - 1, i < 123; ) {
        if ( flag == n - flag - 1 ) {
            out[flag] = mid[place];
            break;
        }
        if ( in[i] ) {
            out[flag] = out[n - flag - 1] = i;
            in[i] -= 2, flag++;
        } else i++;
    }
    out[n] = 0;
}
int main() {
    int n;
    while ( ~scanf ( "%d%s", &n, s ) ) {
        memset ( mid, 0, sizeof mid );
        memset ( in, 0, sizeof in );
        int flag = 0;
        for ( int i = 0; i < n; i++ )
            in[s[i]]++;
        for ( int i = 48; i < 123; i++ )
            if ( in[i] & 1 ) {
                mid[flag++] = i;
                in[i]--;
            }
        if ( !flag ) {
            func1 ( n, 0 );
            printf ( "1\n%s\n", out );
            continue;
        }
        while ( ! ( n % flag == 0 && ( n / flag ) % 2 ) ) {
            for ( int i = 48; i < 123; i++ )
                if ( in[i] ) {
                    mid[flag + 1] = mid[flag] = i;
                    in[i] -= 2;
                    flag += 2;
                    break;
                }
        }
        printf ( "%d\n", flag );
        int huge = n / flag;
        while ( flag-- ) {
            func1 ( huge, flag );
            if ( flag ) printf ( "%s ", out );
            else printf ( "%s\n", out );
        }
    }
    return 0;
}

M. Quadcopter Competition

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
#define abs(a) ((a)<0?-(a):(a))
const int dir[16]= {-1,-1,-1,0,-1,1,0,1,0,-1,1,1,1,-1,1,0};
int Str,End;
int func1(int x1,int x2) {
    return abs(Str-x1)+abs(End-x2);
}
int main() {
    int n,m;
    while(cin>>Str>>End>>n>>m) {
        int Min=2e9+4;
        for(int i=0; i<8; i++)
            Min=min(Min,func1(n+dir[2*i],m+dir[2*i+1]));
        cout<<8+Min*2<<endl;
    }
    return 0;
}