UOJ Round #11 简要题解

从这里开始

• 传送门

　　说好的 agc 045 题解去哪了

Problem A 元旦老人与汉诺塔

　　直接状压每个盘子在哪个柱子，记忆化搜索即可。

　　时间复杂度 O(能过)。

Code

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

#define ull __int128

const int Mod = 998244353;

int n, m;

typedef class Status {
  public:
    ull a, b, c;
    int step;

    Status() {  }
    Status(ull a, ull b, ull c, int step) : a(a), b(b), c(c), step(step) { }

    void read() {
      for (int i = 0, x; i < n; i++) {
        scanf("%d", &x);
        if (x == 1) {
          a |= 1ull << i;
        } else if (x == 2) {
          b |= 1ull << i;
        } else {
          c |= 1ull << i;
        }
      }
    }
    bool operator < (Status t) const {
      if (a ^ t.a)  return a < t.a;
      if (b ^ t.b)  return b < t.b;
      if (c ^ t.c)  return c < t.c;
      return step < t.step;
    }

    bool equal(Status t) {
      return a == t.a && b == t.b && c == t.c;
    }
} Status;

Status ss, st;
map<Status, int> f; 

void inc(int& x) {
  if (x >= Mod) {
    x -= Mod;
  }
}

int F(Status s) {
  if (s.step > m) {
    return 0;
  }
  if (f.count(s)) {
    return f[s];
  }
  ull a = s.a & (-s.a);
  ull b = s.b & (-s.b);
  ull c = s.c & (-s.c);
  int ret = s.equal(st);
  if (a) {
    if (a < b || !b) inc(ret += F(Status(s.a ^ a, s.b ^ a, s.c, s.step + 1)));
    if (a < c || !c) inc(ret += F(Status(s.a ^ a, s.b, s.c ^ a, s.step + 1)));
  }
  if (b) {
    if (b < a || !a) inc(ret += F(Status(s.a ^ b, s.b ^ b, s.c, s.step + 1)));
    if (b < c || !c) inc(ret += F(Status(s.a, s.b ^ b, s.c ^ b, s.step + 1)));
  }
  if (c) {
    if (c < a || !a) inc(ret += F(Status(s.a ^ c, s.b, s.c ^ c, s.step + 1)));
    if (c < b || !b) inc(ret += F(Status(s.a, s.b ^ c, s.c ^ c, s.step + 1)));
  }
  return f[s] = ret;
}

int main() {
  scanf("%d%d", &n, &m);
  ss.read();
  st.read();
  int ans = F(ss);
  printf("%d
", ans);
	return 0;
}

Problem B 元旦老人与丛林

　　注意到一个必要条件是任意一个点集 $V$ 的导出子图的边集大小不会超过 $2|V| - 2$。可以证明这个是充分的。

　　证明考虑归纳法，当 $n = 1$ 的时候显然满足。

　　现在考虑 $n > 1$ 的情况，并假设 $n$ 更小的时候成立。

　　考虑图中度数最小的 $x$，那么 $x$ 的度数只可能为 $0, 1, 2, 3$。

　　对于前 3 种情况可以简单地分配与它相邻的边使得它在 2 个新图中的度数均不超过 1。下面找考虑 $x$ 的度数为 3 的情况。

　　我们称一个子图 $G = (V, E)$ 是满的，当且仅当 $2|V| - 2 = |E|$。

引理 如果 $G_1 = (V_1, E_1), G_2 = (V_2, E_2)$ 都是满子图，并且 $V_1 cap V_2 eq nothing$，那么 $G = (V_1 cup V_2, E_1 cup E_2), G_3  = (V_1 cap V_2, E_1 cap E_2)$ 都是满子图。

　　证明  $|E_1 cup E_2| = |E_1| + |E_2| - |E_1cap E_2| geqslant 2|V_1| - 2 + 2|V_2| - 2 - (2|V_1cap V_2| - 2) = 2|V_1 cup V_2| - 2$，又因为 $|E_1 cup E_2| leqslant 2|V_1 cup V_2| - 2$，所以有 $|E_1 cup E_2| =2|V_1 cup V_2| - 2$。

　　用类似的方法可以证得 $G_3$ 是满子图。

　　考虑和 $x$ 相邻的三个点 $a, b, c$。设删掉 $x$ 及其相邻的边后得到的图是 $G'$。

定理 $(a, b), (b, c), (a, c)$ 中至少存在一对 $(u, v)$ 满足同时包含 $(u, v)$ 的导出子图都不是满子图 

　　证明 考虑反证法，在这三对各找一个使得它是满子图的子图，然后把它们并起来，这样得到了一个同时包含 $a, b, c$ 的满子图，这时候加入 $x$ 和它相邻的边，显然此时不满足条件。

　　假设 $G'$ 中同时包含 $a, b$ 的导出子图都不是满子图，那么在 $G'$ 中加入边 $(a,b)$ 得到 $G''$，然后根据归纳假设有 $G''$ 是丛林。因此我们得到了两个森林，在包含 $(a, b)$ 的边的森林中，删除 $(a, b)$，然后加入 $(x, a), (x, b)$，再在另外一边加入 $(x, c)$。

　　剩下的问题是判断是否存在一个点集 $V$，它导出的边集 $E$，满足 $frac{|E|}{|V| - 1} > 2$。

　　直接最大权闭合子图有点问题，因为它可能 $|V|$ 选空集，然后这样就会 GG。

　　每次硬点一个点必须选，退流就可以了。

　　时间复杂度 $O(nm)$。

Code

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

const int inf = (signed) (~0u >> 2);

typedef class Edge {
	public:
		int ed, nx, r;

		Edge() {	}
		Edge(int ed, int nx, int r) : ed(ed), nx(nx), r(r) {	}
} Edge;

typedef class MapManager {
	public:
		vector<int> h;
		vector<Edge> E;
		
		MapManager() {	}
		MapManager(int n) {
			h.assign(n + 1, -1);
		}
		void add_edge(int u, int v, int c) {
			E.emplace_back(v, h[u], c);
			h[u] = (signed) E.size() - 1;
		}

		Edge& operator [] (int p) {
			return E[p];
		}
} MapManager;

typedef class Network {
	public:
		int S, T;
		MapManager g;
		vector<int> div;
		int rest_flow;
		
		Network() {	}
		Network(int S, int T) : S(S), T(T), g(T + 1) {
			div.resize(T + 1);
		}

		bool bfs() {
			queue<int> Q;
			fill(div.begin(), div.end(), -1);
			Q.push(S);
			div[S] = 0;
			while (!Q.empty()) {
				int p = Q.front();
				Q.pop();
				if (p == T) {
					continue;
				}
				for (int i = g.h[p]; ~i; i = g[i].nx) {
					int e = g[i].ed;
					if (!g[i].r || ~div[e]) {
						continue;
					}
					div[e] = div[p] + 1;
					Q.push(e);
				}
			}
			return div[T] != -1;
		}

		vector<int> cur;
		int dfs(int p, int mf) {
			if (p == T || !mf) {
				rest_flow -= mf;
				if (!rest_flow) {
					throw 1;
				}
				return mf;
			}
			int flow = 0, f;
			for (int& i = cur[p]; ~i; i = g[i].nx) {
				int e = g[i].ed;
				if (div[e] == div[p] + 1 && (f = dfs(e, min(mf, g[i].r))) > 0) {
					flow += f;
					g[i].r -= f;
					g[i ^ 1].r += f;
					mf -= f;
					if (!mf) {
						break;
					}
				}
			}
			return flow;
		}

		int dinic() {
			int ret = 0;
			try {
				while (bfs()) {
					cur = g.h;
					ret += dfs(S, inf);
				}
			} catch (int) {
				return 2;
			}
			return ret;
		}
		
		void add_edge(int u, int v, int c) {
			g.add_edge(u, v, c);
			g.add_edge(v, u, 0);
		}

		vector<bool> get_S() {
			vector<bool> vis (T + 1, false);
			queue<int> Q;
			Q.push(S);
			vis[S] = true;
			while (!Q.empty()) {
				int p = Q.front();
				Q.pop();
				for (int i = g.h[p]; ~i; i = g[i].nx) {
					int e = g[i].ed;
					if (!vis[e] && g[i].r) {
						vis[e] = true;
						Q.push(e);
					}
				}
			}
			return vis;
		}
} Network;

int n, m, lim;

int main() {
	scanf("%d%d", &n, &m);
	lim = 2;
	int T;
	Network network(0, T = n + m + 1);
	vector<int> deg (n + 1, 0);
	vector<pair<int, int>> E (m);
	for (int i = 0, u, v; i < m; i++) {
		scanf("%d%d", &u, &v);
		if (u == v) {
			puts("No");
			return 0;
		}
		E[i] = make_pair(u, v);
		++deg[u];
		++deg[v];
	}
	for (int i = 1; i <= n; i++) {
		if (deg[i] >= lim) {
			network.add_edge(i, T, lim);
		}
	}
	int cost = 0;
	for (int i = 1, u, v; i <= m; i++) {
		u = E[i - 1].first, v = E[i - 1].second;
		if (deg[u] >= lim && deg[v] >= lim) {
			network.add_edge(0, n + i, 1);
			network.add_edge(n + i, u, inf);
			network.add_edge(n + i, v, inf);
			++cost;
		}
	}
	network.rest_flow = inf;
	cost -= network.dinic();
	if (cost) {
		puts("No");
		return 0;
	} else {
		auto inS = network.get_S();
		for (int i = 1; i <= n; i++) {
			if (inS[i] && deg[i] >= lim) {
				puts("No");
				return 0;
			}
		}
		for (int i = 1; i <= n; i++) {
			if (deg[i] < lim) {
				continue;
			}
			Network network1 = network;
			network1.add_edge(0, i, lim);
			network1.rest_flow = 2;
			int xx = network1.dinic();
			if (xx < lim) {
				puts("No");
				return 0;
			}
		}
	}
	puts("Yes");
	return 0;
}

Problem C 元旦老人与数列

　　若干 segment tree beats 板题之一。

　　考虑 segment tree beats 本质上是对区间的最小值打标记。当最小值集合发生改变的时候暴力递归。

　　所以对最小值和非区间最小值分别维护区间加标记。

　　因为要查询区间历史最小值，所以再维护一下历史最小值，以及最小值和非最小值的加标记的最小前缀和。

Code

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

typedef class Input {
  protected:
    const static int limit = 65536;
    FILE* file; 

    int ss, st;
    char buf[limit];
  public:

    Input() : file(NULL)	{	};
    Input(FILE* file) : file(file) {	}

    void open(FILE *file) {
      this->file = file;
    }

    void open(const char* filename) {
      file = fopen(filename, "r");
    }

    char pick() {
      if (ss == st)
        st = fread(buf, 1, limit, file), ss = 0;//, cerr << "str: " << buf << "ed " << st << endl;
      return buf[ss++];
    }
} Input;

#define digit(_x) ((_x) >= '0' && (_x) <= '9')

Input& operator >> (Input& in, unsigned& u) {
  char x;
  while (~(x = in.pick()) && !digit(x));
  for (u = x - '0'; ~(x = in.pick()) && digit(x); u = u * 10 + x - '0');
  return in;
}

Input& operator >> (Input& in, unsigned long long& u) {
  char x;
  while (~(x = in.pick()) && !digit(x));
  for (u = x - '0'; ~(x = in.pick()) && digit(x); u = u * 10 + x - '0');
  return in;
}

Input& operator >> (Input& in, int& u) {
  char x;
  while (~(x = in.pick()) && !digit(x) && x != '-');
  int aflag = ((x == '-') ? (x = in.pick(), -1) : (1));
  for (u = x - '0'; ~(x = in.pick()) && digit(x); u = u * 10 + x - '0');
  u *= aflag;
  return in;
}

Input& operator >> (Input& in, long long& u) {
  char x;
  while (~(x = in.pick()) && !digit(x) && x != '-');
  int aflag = ((x == '-') ? (x = in.pick(), -1) : (1));
  for (u = x - '0'; ~(x = in.pick()) && digit(x); u = u * 10 + x - '0');
  u *= aflag;
  return in;
}

Input& operator >> (Input& in, double& u) {
  char x;
  while (~(x = in.pick()) && !digit(x) && x != '-');
  int aflag = ((x == '-') ? (x = in.pick(), -1) : (1));
  for (u = x - '0'; ~(x = in.pick()) && digit(x); u = u * 10 + x - '0');
  if (x == '.') {
    double dec = 1;
    for ( ; ~(x = in.pick()) && digit(x); u = u + (dec *= 0.1) * (x - '0'));
  }
  u *= aflag;
  return in;
}

Input& operator >> (Input& in, char* str) {
  char x;
  while (~(x = in.pick()) && x != '
' && x != ' ')
    *(str++) = x;
  *str = 0;
  return in;
}

Input in (stdin);

typedef class Output {
  protected:
    const static int Limit = 65536;
    char *tp, *ed;
    char buf[Limit];
    FILE* file;
    int precision;

    void flush() {
      fwrite(buf, 1, tp - buf, file);
      fflush(file);
      tp = buf;
    }

  public:

    Output() {	}
    Output(FILE* file) : tp(buf), ed(buf + Limit), file(file), precision(6) {	}
    Output(const char *str) : tp(buf), ed(buf + Limit), precision(6) {
      file = fopen(str, "w");
    }
    ~Output() {
      flush();
    }

    void put(char x) {
      if (tp == ed)
        flush();
      *(tp++) = x;
    }

    int get_precision() {
      return precision;
    }
    void set_percision(int x) {
      precision = x;
    }
} Output;

Output& operator << (Output& out, int x) {
  static char buf[35];
  static char * const lim = buf + 34;
  if (!x)
    out.put('0');
  else {
    if (x < 0)
      out.put('-'), x = -x;
    char *tp = lim;
    for ( ; x; *(--tp) = x % 10, x /= 10);
    for ( ; tp != lim; out.put(*(tp++) + '0'));
  }
  return out;
}

Output& operator << (Output& out, long long x) {
  static char buf[36];
  static char * const lim = buf + 34;
  if (!x)
    out.put('0');
  else {
    if (x < 0)
      out.put('-'), x = -x;
    char *tp = lim;
    for ( ; x; *(--tp) = x % 10, x /= 10);
    for ( ; tp != lim; out.put(*(tp++) + '0'));
  }
  return out;
}

Output& operator << (Output& out, unsigned x) {
  static char buf[35];
  static char * const lim = buf + 34;
  if (!x)
    out.put('0');
  else {
    char *tp = lim;
    for ( ; x; *(--tp) = x % 10, x /= 10);
    for ( ; tp != lim; out.put(*(tp++) + '0'));
  }
  return out;
}

Output& operator << (Output& out, char x)  {
  out.put(x);
  return out;
}

Output& operator << (Output& out, const char* str) {
  for ( ; *str; out.put(*(str++)));
  return out;
}

Output& operator << (Output& out, double x) {
  int y = x;
  x -= y;
  out << y << '.';
  for (int i = out.get_precision(); i; i--, y = x * 10, x = x * 10 - y, out.put(y + '0'));
  return out;
}

Output out (stdout);

const int N = 5e5 + 5;
const int inf = (~0u >> 1);

#define ll long long

typedef class SegTreeNode {
  public:
    int mi, mi2;
    int tga, tga2;
    int hmi, mtga, mtga2;
    SegTreeNode *l, *r;
  
    void init(int x) {
      mi = x;
      mi2 = inf;
      hmi = x;
      tga = tga2 = mtga = mtga2 = 0;
      l = r = NULL;
    }

    void upd(int _tga, int _tga2, int _mtga, int _mtga2) {
      hmi = min(hmi, mi + _mtga);
      mi += _tga;
      (mi2 != inf) && (mi2 += _tga2, 0);
      mtga = min(mtga, tga + _mtga);
      mtga2 = min(mtga2, tga2 + _mtga2);
      tga += _tga;
      tga2 += _tga2;
    }
    void upd(int v) {
      if (v >= mi2) {
        push_down();
        l->upd(v);
        r->upd(v);
        push_up();
      } else if (v > mi) {
        tga += v - mi;
        mtga = min(mtga, tga);
        mi = v;
      }
    }

    void push_up() {
      hmi = min(l->hmi, r->hmi);
      mi = min(l->mi, r->mi);
      if (l->mi == r->mi) {
        mi2 = min(l->mi2, r->mi2);
      } else if (l->mi < r->mi) {
        mi2 = min(l->mi2, r->mi);
      } else {
        mi2 = min(l->mi, r->mi2);
      }
    }
    void push_down() {
      if (tga || tga2 || mtga || mtga2) {
        if (l->mi + tga == mi) {
          l->upd(tga, tga2, mtga, mtga2);
        } else {
          l->upd(tga2, tga2, mtga2, mtga2);
        }
        if (r->mi + tga == mi) {
          r->upd(tga, tga2, mtga, mtga2);
        } else {
          r->upd(tga2, tga2, mtga2, mtga2);
        }
        tga = tga2 = mtga = mtga2 = 0;
      }
    }
} SegTreeNode;

SegTreeNode pool[N << 1];
SegTreeNode* _top = pool;

typedef class SegmentTree {
  public:
    int n;
    SegTreeNode* rt;

    void build(SegTreeNode*& p, int l, int r, int* a) {
      p = _top++;
      if (l == r) {
        p->init(a[l]);
      } else {
        int mid = (l + r) >> 1;
        build(p->l, l, mid, a);
        build(p->r, mid + 1, r, a);
        p->push_up();
      }
    }
    void build(int n, int* a) {
      this->n = n;
      build(rt, 1, n, a);
    }

    void update_add(SegTreeNode* p, int l, int r, int ql, int qr, int a) {
      if (l == ql && r == qr) {
        p->upd(a, a, a, a);
        return;
      }
      p->push_down();
      int mid = (l + r) >> 1;
      if (qr <= mid) {
        update_add(p->l, l, mid, ql, qr, a);
      } else if (ql > mid) {
        update_add(p->r, mid + 1, r, ql, qr, a);
      } else {
        update_add(p->l, l, mid, ql, mid, a);
        update_add(p->r, mid + 1, r, mid + 1, qr, a);
      }
      p->push_up();
    }
    void update_add(int l, int r, int a) {
      update_add(rt, 1, n, l, r, a);
    }

    void update_mx(SegTreeNode* p, int l, int r, int ql, int qr, int v) {
      if (l == ql && r == qr) {
        p->upd(v);
        return;
      }
      p->push_down();
      int mid = (l + r) >> 1;
      if (qr <= mid) {
        update_mx(p->l, l, mid, ql, qr, v);
      } else if (ql > mid) {
        update_mx(p->r, mid + 1, r, ql, qr, v);
      } else {
        update_mx(p->l, l, mid, ql, mid, v);
        update_mx(p->r, mid + 1, r, mid + 1, qr, v);
      }
      p->push_up();
    }
    void update_mx(int l, int r, int v) {
      update_mx(rt, 1, n, l, r, v);
    }

    int query_mi(SegTreeNode* p, int l, int r, int ql, int qr) {
      if (l == ql && r == qr) {
        return p->mi;
      }
      p->push_down();
      int mid = (l + r) >> 1;
      if (qr <= mid) {
        return query_mi(p->l, l, mid, ql, qr);
      } else if (ql > mid) {
        return query_mi(p->r, mid + 1, r, ql, qr);
      }
      int a = query_mi(p->l, l, mid, ql, mid);
      int b = query_mi(p->r, mid + 1, r, mid + 1, qr);
      return min(a, b);
    }
    int query_mi(int l, int r) {
      return query_mi(rt, 1, n, l, r);
    }

    int query_hmi(SegTreeNode* p, int l, int r, int ql, int qr) {
      if (l == ql && r == qr) {
        return p->hmi;
      }
      p->push_down();
      int mid = (l + r) >> 1;
      if (qr <= mid) {
        return query_hmi(p->l, l, mid, ql, qr);
      } else if (ql > mid) {
        return query_hmi(p->r, mid + 1, r, ql, qr);
      }
      int a = query_hmi(p->l, l, mid, ql, mid);
      int b = query_hmi(p->r, mid + 1, r, mid + 1, qr);
      return min(a, b);
    }
    int query_hmi(int l, int r) {
      return query_hmi(rt, 1, n, l, r);
    }
} SegmentTree;

int n, m;
int a[N];
SegmentTree st;

int main() {
  in >> n >> m;
  for (int i = 1; i <= n; i++) {
    in >> a[i];
  }
  st.build(n, a);
  int op, l, r, x;
  while (m--) {
    in >> op >> l >> r;
    if (op <= 2) {
      in >> x;
      if (op == 1) {
        st.update_add(l, r, x);
      } else{
        st.update_mx(l, r, x);
      } 
    } else if (op == 3) {
      out << st.query_mi(l, r) << '
';
    } else {
      out << st.query_hmi(l, r) << '
';
    }
  }
  return 0;
}