东北欧区域赛2016-2017题解【转载】

Problem A. Abbreviation

AC:

#define _CRT_SECURE_NO_DEPRECATE
#define _USE_MATH_DEFINES

#include <cstdio>
#include <iostream>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <memory.h>
#include <utility>
#include <set>
#include <sstream>
#include <vector>
#include <map>
#include <string>
#include <queue>
using namespace std;

#define ll long long
#define pb push_back
#define mp make_pair
#define mod 1000000007
#define inf 1000000000
#define task "abbreviation"


string s, str, abb, word;

bool check(string str)
{
	for (int i = 0; i < (int)(str.size()); ++i)
	{
		if (i == 0)
		{
			if (str[i] >= 'A' && str[i] <= 'Z')
				continue;
			return false;
		}

		if (str[i] >= 'a' && str[i] <= 'z')
		{
			continue;
		}
		if (str[i] >= 'A' && str[i] <= 'Z')
			return false;
	}
	return (int)str.size() > 1;
}

bool isChars(char c)
{
	return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
}
int l = 0, r = 0;

string getWord()
{
	string w = "";
	while (r < (int)s.size() && !isChars(s[r]))
		++r;
	while (r < (int)s.size() && isChars(s[r]))
	{
		w += s[r];
		++r;
	}
	return w;
}

bool checkEnd()
{
	int sp = 0, cnt = 0;
	while (r < (int)s.size() && !isChars(s[r]))
	{
		if (s[r] == ' ')
			sp++;
		else
			++cnt;
		++r;
	}
	return !(sp == 1 && cnt == 0);
}

void printPrefix()
{
	while (l < (int)s.size() && !isChars(s[l]))
	{
		cout << s[l];
		++l;
	}
}
int printAbb()
{
	printPrefix();
	if (abb.size() > 1)
	{
		cout << abb << " (" << str << ")";
		l = r;
		str = "";
		abb = "";
		return 1;
	}
	else
	{
		for (; l < r; ++l)
			cout << s[l];
		str = "";
		abb = "";
		return 0;
	}
	
}

void printEnd()
{
	int rr = r - (int)word.size() - 1;
	int left = rr;
	while (left > 0 && !isChars(s[left]))
	{
		left--;
	}
	left++;
	for (; left <= rr; ++left)
		cout << s[left];
}

void printEnd2()
{
	int rr = r - 1;
	int left = rr;
	while (left > 0 && !isChars(s[left]))
	{
		left--;
	}
	left++;
	for (; left <= rr; ++left)
		cout << s[left];
}
void init()
{
	while (getline(cin, s))
	{
		l = r = 0;
		while (1)
		{

			word = getWord();
			if (word == "")
			{
				if (printAbb())
					printEnd();
				break;
			}
			if (check(word))
			{
				abb += word[0];
				if (str != "")
					str += ' ';
				str = str + word;
				if (!checkEnd())
					continue;
				else
					if (printAbb())
						printEnd2();
			}
			else
			{
				if (printAbb())
				{
					printEnd();
					cout << word;
				}
			}
		}
		cout << endl;
	}
}

void solve()
{

}

int main()
{
	//freopen("input.txt", "rt", stdin); freopen("output.txt", "wt", stdout);
	freopen("abbreviation.in", "rt", stdin); freopen("abbreviation.out", "wt", stdout);
	init();
	//solve();
	return 0;
}

AC:

#include <bits/stdc++.h>
using namespace std;

char s[2000][200];
char c[400];
int n;

int len(int k, int i){
    if((s[k][i] >= 'A' && s[k][i] <= 'Z') || (s[k][i] >= 'a' && s[k][i] <= 'z') ){
        int l = 0;
        while(i+l < n && ((s[k][i+l] >= 'A' && s[k][i+l] <= 'Z') || (s[k][i+l] >= 'a' && s[k][i+l] <= 'z')))
            l++;
        return l;
    }
    else
        return 1;
}

bool cap(int k, int i){
    if(!(s[k][i] >= 'A' && s[k][i] <= 'Z'))
        return false;
    i++;
    int l = 0;
    while(i < n && s[k][i] >= 'a' && s[k][i] <= 'z')
        i++, l++;
    if (l == 0)
        return false;
    if(i == n)
        return true;
    if(i < n && !(s[k][i] >= 'A' && s[k][i] <= 'Z'))
        return true;
    return false;
}

void write(int k, int i, int j){
    string abbr;
    for(int it = i; it != j; it++){
        if(s[k][it] >= 'A' && s[k][it] <= 'Z')
            abbr.push_back(s[k][it]);
    }

    char b = s[k][j];
    s[k][j] = 0;
    printf("%s (%s)", abbr.c_str(), &s[k][i]);
    s[k][j] = b;
}

void proc(int k){
    int i = 0;
    n = strlen(s[k]);
    while(i < n){
        int j = i;
        int num = 0;
        while(cap(k, j) && j < n){
                j += len(k, j);
                num++;
                if(s[k][j] != ' ')
                    break;
                else j++;
        }
        if(num > 1){
            j--;
            while(!(s[k][j] >= 'a' && s[k][j] <= 'z') )j--;
            j++;
            write(k, i, j);
            i = j;
        }
        else {
            j = i+len(k, i);
            char b = s[k][j];
            s[k][j] = 0;
            printf("%s", &s[k][i]);
            s[k][j] = b;
            i = j;
        }
    }
    printf("\n");
}


int main()
{
    freopen("abbreviation.in", "rt", stdin);
    freopen("abbreviation.out", "wt", stdout);

    int i = 0;
    while(gets(s[i])){
        proc(i);
    }

    return 0;
}

Problem B. Binary Code

AC:

#ifdef DEBUG
#define _GLIBCXX_DEBUG
#endif

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef long double ld;

#define sz(x) ((int) (x).size())
#define mp make_pair
#define pb push_back
#ifdef DEBUG
#define eprintf(...) fprintf(stderr, __VA_ARGS__), fflush(stderr)
#else
#define eprintf(...) ;
#endif
#define TASK "binary"

const int inf = (int) 1.01e9;
const ld eps = 1e-9;
const ld pi = acos((ld) -1);


void precalc() {
}

struct node {
  int go[2];
  vector<int> xs;
};

const int maxn = (int) 1e6 + 10;
int n;
string s[maxn];
char tmp[maxn];

int read() {
  if (!(cin >> n)) {
    return 0;
  }
  for (int i = 0; i < n; i++) {
    cin >> s[i];
  }
  return 1;
}

node trie[maxn];
int freeNode;
int ids[maxn];
int vs;

int newNode() {
  assert(freeNode < maxn);
  for (int i = 0; i < 2; i++) {
    trie[freeNode].go[i] = -1;
  }
  trie[freeNode].xs.clear();
  return freeNode++;
}

void add(const string &s, int x) {
  int v = 0;
  for (int i = 0; i < sz(s); i++) {
    if (trie[v].go[s[i] - '0'] == -1) {
      trie[v].go[s[i] - '0'] = newNode();
    }
    v = trie[v].go[s[i] - '0'];
  }
  trie[v].xs.push_back(x);
}

const int maxv = 3 * maxn, maxe = maxn * 12;
#define next mnext
int head[maxv];
int next[maxe];
int to[maxe];
int cnte;

int head2[maxv];
int next2[maxe];
int to2[maxe];
int cnte2;

void adde(int s, int t) {
  assert(cnte < maxe);
  next[cnte] = head[s];
  head[s] = cnte;
  to[cnte] = t;
  ++cnte;
}

void adde2(int s, int t) {
  assert(cnte2 < maxe);
  next2[cnte2] = head2[s];
  head2[s] = cnte2;
  to2[cnte2] = t;
  ++cnte2;
}

void addEdge(int v, int u) {
  adde(v ^ 1, u);
  adde2(u, v ^ 1);
  adde(u ^ 1, v);
  adde2(v, u ^ 1);
}

void dfs(int v, int p) {
  for (int i = 0; i < sz(trie[v].xs); i++) {
    int cur = vs;
    vs += 2;
    if (p != -1) {
      addEdge(cur, p + 1);
      addEdge((trie[v].xs[i] ^ 1), p + 1);
    }
    addEdge(cur, (trie[v].xs[i] ^ 1));
    p = cur;
  }
  for (int i = 0; i < 2; i++) {
    int u = trie[v].go[i];
    if (u == -1) {
      continue;
    }
    dfs(u, p);
  }
}

int p[maxv], ps;
int used[maxv], c[maxv];

int st[maxv];
int its[maxv];

void dfs0(int v) {
  its[v] = head[v];
  st[0] = v;
  int r = 1;
  while (r > 0) {
    int v = st[r - 1];
    used[v] = 1;
    int &it = its[v];
    if (it == -1) {
      p[ps++] = v;
      --r;
      continue;
    }
    int u = to[it];
    it = next[it];
    if (!used[u]) {
      st[r++] = u;
      its[u] = head[u];
    }
  }
}

int maxcol;

void dfs1(int v) {
  st[0] = v;
  its[v] = head2[v];
  int r = 1;
  while (r > 0) {
    int v = st[r - 1];
    assert(0 <= v && v < vs);
    used[v] = 1;
    c[v] = maxcol;
    int &it = its[v];
    if (it == -1) {
      --r;
      continue;
    }
    int u = to2[it];
    it = next2[it];
    if (!used[u]) {
      st[r++] = u;
      its[u] = head2[u];
    }
  }
}

int res[maxv];

void solve() {
  memset(head, -1, sizeof(head));
  memset(head2, -1, sizeof(head2));
  cnte = cnte2 = 0;
  freeNode = 0;
  newNode();
  vs = 0;
  for (int i = 0; i < n; i++) {
    int pos = find(s[i].begin(), s[i].end(), '?') - s[i].begin();
    if (pos == sz(s[i])) {
      ids[i] = -1;
      add(s[i], vs);
      addEdge(vs, vs);
      vs += 2;
    } else {
      ids[i] = vs / 2;
      s[i][pos] = '0';
      add(s[i], vs);
      s[i][pos] = '1';
      add(s[i], vs + 1);
      s[i][pos] = '?';
      vs += 2;
    }
  }
  dfs(0, -1);
  assert(vs <= maxv);
  for (int i = 0; i < vs; i++) {
    used[i] = false;
  }
  ps = 0;
  memset(its, 0, sizeof(its));
  for (int i = 0; i < vs; i++) {
    if (!used[i]) {
      dfs0(i);
    }
  }
  int cs = 0;
  for (int i = 0; i < vs; i++) {
    used[i] = false;
  }
  memset(its, 0, sizeof(its));
  for (int i = vs - 1; i >= 0; i--) {
    int v = p[i];
    if (!used[v]) {
      maxcol = cs++;
      dfs1(v);
    }
  }
  for (int i = 0; i < vs; i++) {
    if (c[i] == c[i ^ 1]) {
      cout << "NO\n";
      return;
    }
  }
  cout << "YES\n";
  for (int i = 0; i < vs; i++) {
    used[i / 2] = false;
  }
  for (int i = 0; i < vs; i++) {
    int v = p[i];
    if (!used[v / 2]) {
      res[v / 2] = (v & 1);
      used[v / 2] = true;
    }
  }
  for (int i = 0; i < n; i++) {
    if (ids[i] == -1) {
      continue;
    }
    int pos = find(s[i].begin(), s[i].end(), '?') - s[i].begin();
    s[i][pos] = '0' + res[ids[i]];
  }
  for (int i = 0; i < n; i++) {
    cout << s[i] << '\n';
  }
}

int main() {
  precalc();
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  freopen(TASK ".out", "w", stdout);
  freopen(TASK ".in", "r", stdin);
  
  while (read()) {
    solve();
    eprintf("Time %.2f\n", (double) clock() / CLOCKS_PER_SEC);
  }
  
  return 0;
}

Problem C. Cactus Construction

Problem D. Delight for a Cat

Problem E. Expect to Wait

Problem F. Foreign Postcards

Problem G. Game on Graph

Problem H. Hard Refactoring

Problem I. Indiana Jones and the Uniform Cave

Problem J. Jenga Boom

Problem K. Kids Designing Kids

Problem L. List of Primes

Problem M. Mole Tunnels