Solve alot of problems :3

Author: AliOsm

CodeForces/218C. Ice Skating.cpp

@@ -0,0 +1,42 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int n, a[101], b[101];
+bool vis[101];
+vector<vector<int> > g;
+
+void dfs(int v) {
+	vis[v] = true;
+
+	for(int i = 0, u; i < g[v].size(); ++i) {
+		u = g[v][i];
+		if(!vis[u])
+			dfs(u);
+	}
+}
+
+int main() {
+	scanf("%d", &n);
+	for(int i = 0; i < n; ++i)
+		scanf("%d %d", a + i, b + i);
+
+	g.resize(n);
+	for(int i = 0; i < n; ++i)
+		for(int j = 0; j < n; ++j)
+			if(a[i] == a[j] || b[i] == b[j]) {
+				g[i].push_back(j);
+				g[j].push_back(i);
+			}
+
+	int res = 0;
+	for(int i = 0; i < n; ++i)
+		if(!vis[i]) {
+			++res;
+			dfs(i);
+		}
+
+	printf("%d\n", res - 1);
+
+  return 0;
+}

CodeForces/427C. Checkposts.cpp

@@ -0,0 +1,77 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int const N = 1e5 + 1, MOD = 1e9 + 7;
+int n, m, a[N], dfs, comp, idx[N], low[N];
+bool in[N];
+vector<int> st;
+vector<vector<int> > g, comps;
+
+void DFS(int v) {
+  low[v] = idx[v] = dfs++;
+  in[v] = true;
+  st.push_back(v);
+
+  for(int i = 0; i < g[v].size(); i++)
+    if(idx[g[v][i]] == -1) {
+      DFS(g[v][i]);
+      low[v] = min(low[v], low[g[v][i]]);
+    } else if(in[g[v][i]])
+      low[v] = min(low[v], low[g[v][i]]);
+
+  if(low[v] == idx[v]) {
+    int node;
+    do {
+      node = st.back();
+      in[node] = false;
+      st.pop_back();
+      comps[comp].push_back(node);
+    } while(node != v);
+
+    comp++;
+  }
+}
+
+int main() {
+	scanf("%d", &n);
+	g.resize(n);
+	comps.resize(n);
+	for(int i = 0; i < n; ++i)
+		scanf("%d", a + i);
+	scanf("%d", &m);
+	for(int i = 0, a, b; i < m; ++i) {
+		scanf("%d %d", &a, &b);
+		--a, --b;
+		g[a].push_back(b);
+	}
+
+	memset(idx, -1, sizeof idx);
+	memset(in, false, sizeof in);
+	dfs = comp = 0;
+  for(int i = 0; i < n; i++)
+    if(idx[i] == -1)
+			DFS(i);
+
+	long long res = 0, ways = 1;
+	for(int i = 0; i < comps.size(); ++i, puts("")) {
+		if(comps[i].empty())
+			break;
+
+		int mnv = 2e9, mni;
+		for(int j = 0; j < comps[i].size(); ++j)
+			if(a[comps[i][j]] < mnv)
+				mnv = a[comps[i][j]], mni = comps[i][j];
+		res += a[mni];
+
+		int rep = 0;
+		for(int j = 0; j < comps[i].size(); ++j)
+			if(a[comps[i][j]] == a[mni])
+				++rep;
+		ways = ways * rep % MOD;
+	}
+
+	printf("%lld %lld\n", res, ways);
+
+  return 0;
+}

CodeForces/467D. Fedor and Essay.cpp

@@ -0,0 +1,118 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+struct node {
+	int rRep, len, v;
+
+	node() {}
+	node(int rRep, int len, int v) :
+	rRep(rRep), len(len), v(v) {}
+	
+	bool operator<(const node &n) const {
+		if(rRep != n.rRep)
+			return rRep > n.rRep;
+		if(len != n.len)
+			return len > n.len;
+		return false;
+	}
+};
+
+int const N = 5e5 + 1;
+int m, n, id, lst, rRep[N], len[N], wRep[N];
+char s[N];
+bool vis[N];
+string tmp;
+node cur;
+map<string, int> mp;
+priority_queue<node> q;
+vector<vector<int> > g;
+
+void Dijkstra() {
+	while(!q.empty()) {
+		cur = q.top();
+		q.pop();
+
+		if(cur.v < lst && (cur.rRep < rRep[cur.v] ||
+											(cur.rRep == rRep[cur.v]) && cur.len < len[cur.v]))
+			rRep[cur.v] = cur.rRep, len[cur.v] = cur.len;
+
+		if(vis[cur.v])
+			continue;
+		vis[cur.v] = true;
+
+		for(int i = 0; i < g[cur.v].size(); ++i) {
+			if(rRep[g[cur.v][i]] < cur.rRep ||
+				(rRep[g[cur.v][i]] == cur.rRep && len[g[cur.v][i]] < cur.len))
+				q.push(node(rRep[g[cur.v][i]], len[g[cur.v][i]], g[cur.v][i]));
+			else
+				q.push(node(cur.rRep, cur.len, g[cur.v][i]));
+		}
+	}
+}
+
+int main() {
+	scanf("%d", &m);
+	for(int i = 0; i < m; ++i) {
+		scanf("%s", s);
+		tmp = s;
+		transform(tmp.begin(), tmp.end(), tmp.begin(), ::tolower);
+		if(mp.count(tmp) == 0) {
+			mp[tmp] = id;
+			for(int j = 0; j < tmp.length(); ++j)
+				rRep[id] += (tmp[j] == 'r');
+			len[id] = tmp.length();
+
+			++id;
+		}
+		++wRep[mp[tmp]];
+	}
+	lst = id;
+
+	g.resize(N);
+
+	scanf("%d", &n);
+	for(int i = 0, a, b; i < n; ++i) {
+		scanf("%s", s);
+		tmp = s;
+		transform(tmp.begin(), tmp.end(), tmp.begin(), ::tolower);
+		if(mp.count(tmp) == 0) {
+			mp[tmp] = id;
+			for(int j = 0; j < tmp.length(); ++j)
+				rRep[id] += (tmp[j] == 'r');
+			len[id] = tmp.length();
+
+			++id;
+		}
+		a = mp[tmp];
+		q.push(node(rRep[a], len[a], a));
+
+		scanf("%s", s);
+		tmp = s;
+		transform(tmp.begin(), tmp.end(), tmp.begin(), ::tolower);
+		if(mp.count(tmp) == 0) {
+			mp[tmp] = id;
+			for(int j = 0; j < tmp.length(); ++j)
+				rRep[id] += (tmp[j] == 'r');
+			len[id] = tmp.length();
+
+			++id;
+		}
+		b = mp[tmp];
+		q.push(node(rRep[b], len[b], b));
+
+		g[b].push_back(a);
+	}
+
+	Dijkstra();
+
+	long long r1 = 0, r2 = 0;
+	for(int i = 0; i < lst; ++i) {
+		r1 += 1ll * rRep[i] * wRep[i];
+		r2 += 1ll * len[i] * wRep[i];
+	}
+
+	printf("%lld %lld\n", r1, r2);
+
+  return 0;
+}

CodeForces/557C. Arthur and Table.cpp

@@ -0,0 +1,83 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int const N = 1e5 + 1;
+int n, cs[N][201];
+pair<int, int> all[N];
+set<int> st;
+map<int, pair<int, int> > mp;
+
+int work(int val) {
+	int ret = 0;
+
+	int s = mp[val].first, e = mp[val].second;
+
+	for(int i = 0; i < 201; ++i)
+		ret += i * (cs[n - 1][i] - cs[e][i]);
+
+	int mxr = e - s + 1;
+	int otr = s;
+
+	if(mxr == otr) {
+		for(int i = 0; i < 201; ++i)
+			if(cs[s - 1][i] != 0) {
+				ret += i;
+				break;
+			}
+	} else if(mxr < otr) {
+		int need = otr - mxr + 1;
+		for(int i = 0; need > 0 && i < 201; ++i) {
+			if(cs[s - 1][i] >= need) {
+				ret += i * need;
+				break;
+			}
+			else {
+				need -= cs[s - 1][i];
+				ret += i * cs[s - 1][i];
+			}
+		}
+	}
+
+	return ret;
+}
+
+int main() {
+	scanf("%d", &n);
+	for(int i = 0; i < n; ++i) {
+		scanf("%d", &all[i].first);
+		st.insert(all[i].first);
+	}
+	for(int i = 0; i < n; ++i)
+		scanf("%d", &all[i].second);
+	sort(all, all + n);
+
+	if(n == 1) {
+		puts("0");
+		return 0;
+	}
+
+	for(int i = 0; i < n; ++i) {
+		if(mp.count(all[i].first))
+			mp[all[i].first].second = i;
+		else {
+			mp[all[i].first].first = i;
+			mp[all[i].first].second = i;
+		}
+	}
+
+	++cs[0][all[0].second];
+	for(int i = 1; i < n; ++i) {
+		for(int j = 0; j < 201; ++j)
+			cs[i][j] = cs[i - 1][j];
+		++cs[i][all[i].second];
+	}
+
+	int res = 2e9;
+	for(set<int>::iterator it = st.begin(); it != st.end(); ++it)
+		res = min(res, work(*it));
+
+	printf("%d\n", res);
+
+  return 0;
+}