Submission #244270

---

Source Code Expand

#include<vector>
#include<string>
#include<algorithm>
#include<set>
#include<map>
#include<queue>
#include<cmath>
#include<cstdio>
#include<iostream>
#include<sstream>
#include<functional>
#include<cstring>
#include<cstdlib>
#define MOD 1000000007
#define ADD(X,Y) ((X) = ((X) + (Y)%MOD) % MOD)
#define chmax(a, b) (a) = max(a, b)
#define chmin(a, b) (a) = min(a, b)
#define mp make_pair
using namespace std;
typedef long long i64; typedef vector<int> ivec; typedef vector<string> svec;

template <class C>
void Dijkstra(int N, int S, vector<pair<int, C> > *graph, C *sol) {
	// graph[i]: (dest, cost (>= 0) ) list
	// sol[i]: (mincost from S to pt[i])
	C infv = 2100000000; // inf value
	for (int i = 0; i < N; ++i) sol[i] = infv;
	priority_queue<pair<C, int> > Q;

	Q.push(make_pair(C(0), S));
	while (!Q.empty()) {
		pair<C, int> tmp = Q.top(); Q.pop();
		int pt = tmp.second;
		if (sol[pt] != infv) continue;
		sol[pt] = -tmp.first;

		for (int i = 0; i < graph[pt].size(); ++i) {
			pair<int, C> &e = graph[pt][i];
			Q.push(make_pair(tmp.first - e.second, e.first));
		}
	}
}

struct UnionFind
{
	int *val, N;

	UnionFind() { val = NULL; }
	UnionFind(int N) : N(N) { val = new int[N]; fill(val, val + N, -1); }
	~UnionFind() { delete[] val; }
	int root(int p) { return val[p] < 0 ? p : (val[p] = root(val[p])); }
	bool join(int p, int q) {
		p = root(p); q = root(q);
		if (p == q) return false;
		if (val[p] > val[q]) swap(p, q);
		val[p] += val[q];
		val[q] = p;
		return true;
	}
};

#define WF(matr, SZ) for(int i = 0; i < (SZ); ++i) for(int j = 0; j < (SZ); ++j) for(int k = 0; k < (SZ); ++k) matr[j][k] = min(matr[j][k], matr[j][i] + matr[i][k]);

namespace MCF {
#define MAXN 1
#define MAXM 1
#define wint int
#define cint int
	const wint wEPS = 0;
	const wint wINF = 1001001001;
	const cint cEPS = 0;
	const cint cINF = 1001001001;
	int n, m, ptr[MAXN], next[MAXM], zu[MAXM];
	wint capa[MAXM], tof;
	cint cost[MAXM], toc, d[MAXN], pot[MAXN];
	int vis[MAXN], pree[MAXN];
	void init(int _n) {
		n = _n; m = 0; memset(ptr, ~0, n * 4);
	}
	void ae(int u, int v, wint w, cint c) {
		next[m] = ptr[u]; ptr[u] = m; zu[m] = v; capa[m] = w; cost[m] = +c; ++m;
		next[m] = ptr[v]; ptr[v] = m; zu[m] = u; capa[m] = 0; cost[m] = -c; ++m;
	}
	bool solve(int src, int ink, wint flo = wINF) {
		int i, u, v;
		wint f;
		cint c, cc;
		memset(pot, 0, n * sizeof(cint));
		//*
		for (bool cont = 1; cont;) {
			cont = 0;
			for (u = 0; u < n; ++u) for (i = ptr[u]; ~i; i = next[i]) if (capa[i] > wEPS) {
				if (pot[zu[i]] > pot[u] + cost[i] + cEPS) {
					pot[zu[i]] = pot[u] + cost[i]; cont = 1;
				}
			}
		}
		//*/
		for (toc = 0, tof = 0; tof + wEPS < flo;) {
			typedef pair<cint, int> node;
			priority_queue< node, vector<node>, greater<node> > q;
			for (u = 0; u < n; ++u) { d[u] = cINF; vis[u] = 0; }
			for (q.push(mp(d[src] = 0, src)); !q.empty();) {
				c = q.top().first; u = q.top().second; q.pop();
				if (vis[u]++) continue;
				for (i = ptr[u]; ~i; i = next[i]) if (capa[i] > wEPS) {
					cc = c + cost[i] + pot[u] - pot[v = zu[i]];
					if (d[v] > cc) { q.push(mp(d[v] = cc, v)); pree[v] = i; }
				}
			}
			if (!vis[ink]) return 0;
			f = flo - tof;
			for (v = ink; v != src; v = zu[i ^ 1]) { i = pree[v]; chmin(f, capa[i]); }
			for (v = ink; v != src; v = zu[i ^ 1]) { i = pree[v]; capa[i] -= f; capa[i ^ 1] += f; }
			tof += f;
			toc += f * (d[ink] - pot[src] + pot[ink]);
			for (u = 0; u < n; ++u) pot[u] += d[u];
		}
		return 1;
	}
}

namespace MF {
#define MAXN 1
#define MAXM 1
#define wint int
#define cint int
#define cdouble double
	int n, m, ptr[MAXN], next[MAXM], zu[MAXM];
	wint capa0[MAXM], capa[MAXM], ex[MAXN];
	cint cost[MAXM];
	cdouble pot[MAXN];
	bool vis[MAXN];
	int itr[MAXN], lev[MAXN], que[MAXN], *qb, *qe;
	void init(int _n) {
		n = _n; m = 0; memset(ptr, ~0, n * 4); memset(ex, 0, n * sizeof(wint));
	}
	void ae(int u, int v, wint w, cint c) {
		next[m] = ptr[u]; ptr[u] = m; zu[m] = v; capa0[m] = capa[m] = w; cost[m] = +c; ++m;
		next[m] = ptr[v]; ptr[v] = m; zu[m] = u; capa0[m] = capa[m] = 0; cost[m] = -c; ++m;
	}
	wint augment(int u, int t, wint flo) {
		if (u == t) return flo;
		wint f;
		for (int &i = itr[u]; ~i; i = next[i]) if (capa[i] > 0 && lev[u] < lev[zu[i]]) {
			if ((f = augment(zu[i], t, min(flo, capa[i]))) > 0) {
				capa[i] -= f; capa[i ^ 1] += f; return f;
			}
		}
		return 0;
	}
	wint augment(int u, wint flo) {
		wint f;
		if (ex[u] < 0) {
			f = min(flo, -ex[u]); ex[u] += f; return f;
		}
		for (int &i = itr[u]; ~i; i = next[i]) if (capa[i] > 0 && cost[i] + pot[u] - pot[zu[i]] < 0) {
			if ((f = augment(zu[i], min(flo, capa[i]))) > 0) {
				capa[i] -= f; capa[i ^ 1] += f; return f;
			}
		}
		return 0;
	}
	wint dinic(int s, int t, wint flo) {
		int i, u, v;
		wint tof = 0, f;
		for (; tof < flo;) {
			qb = qe = que; memset(lev, ~0, n * 4); memcpy(itr, ptr, n * 4);
			for (lev[*qe++ = s] = 0; qb != qe;) {
				for (i = ptr[u = *qb++]; ~i; i = next[i]) if (capa[i] > 0 && !~lev[v = zu[i]]) {
					lev[*qe++ = v] = lev[u] + 1;
				}
			}
			if (!~lev[t]) break;
			for (; (f = augment(s, t, flo - tof)) > 0;) tof += f;
		}
		return tof;
	}
	void dfs(int u) {
		if (vis[u]) return; vis[u] = 1;
		for (int i = ptr[u]; ~i; i = next[i]) if (capa[i] > 0 && cost[i] + pot[u] - pot[zu[i]] < 0) {
			dfs(zu[i]);
		}
	}
	cint solve() {
		int i, u;
		wint f;
		cdouble eps = 0;
		for (i = 0; i < m; ++i) if (capa[i] > 0) chmax(eps, (cdouble)-cost[i]);
		for (; eps * n >= 1;) {
			eps /= 4;
			for (i = 0; i < m; ++i) if (capa[i] > 0 && cost[i] + pot[zu[i ^ 1]] - pot[zu[i]] < 0) {
				ex[zu[i ^ 1]] -= capa[i]; ex[zu[i]] += capa[i]; capa[i ^ 1] += capa[i]; capa[i] = 0;
			}
			for (;;) {
				memset(vis, 0, n); memcpy(itr, ptr, n * 4);
				for (u = 0; u < n; ++u) if (ex[u] > 0) dfs(u);
				for (u = 0; u < n; ++u) if (vis[u]) pot[u] -= eps;
				for (u = 0; u < n; ++u) for (; ex[u] > 0 && (f = augment(u, ex[u])) > 0;) ex[u] -= f;
				for (u = 0; u < n; ++u) if (ex[u] > 0) break;
				if (u == n) break;
			}
		}
		cint toc = 0;
		for (i = 0; i < m; ++i) if (capa0[i] > capa[i]) toc += (capa0[i] - capa[i]) * cost[i];
		return toc;
	}
}

struct DynRMinQ
{
	static const int DEPTH = 18;
	static const int N = 1 << DEPTH;
	int val[N * 2];

	void Init() {
		for (int i = 0; i < N * 2; ++i) val[i] = 2100000000;
	}
	void Set(int p, int v) {
		val[p += N] = v; p >>= 1;
		while (p) { val[p] = min(val[p * 2], val[p * 2 + 1]); p >>= 1; }
	}
	int Query(int L, int R) { // [L, R)
		L += N; R += N;
		int ret = 2100000000;
		while (L < R) {
			if (L & 1) ret = min(ret, val[L++]);
			if (R & 1) ret = min(ret, val[--R]);
			L >>= 1; R >>= 1;
		}
		return ret;
	}
};

struct DynRMaxQ
{
	static const int DEPTH = 18;
	static const int N = 1 << DEPTH;
	int val[N * 2];

	void Init() {
		for (int i = 0; i < N * 2; ++i) val[i] = -2100000000;
	}
	void Set(int p, int v) {
		val[p += N] = v; p >>= 1;
		while (p) { val[p] = max(val[p * 2], val[p * 2 + 1]); p >>= 1; }
	}
	int Query(int L, int R) { // [L, R)
		L += N; R += N;
		int ret = -2100000000;
		while (L < R) {
			if (L & 1) ret = max(ret, val[L++]);
			if (R & 1) ret = max(ret, val[--R]);
			L >>= 1; R >>= 1;
		}
		return ret;
	}
};

struct BIT
{
	static const int N = 200202;
	int val[N];
	// NOTE : 0-origin! Add(p, x) : a[p] += x; Sum(i) = a[1] + a[2] + ... + a[i - 1]
	void Init() { for (int i = 0; i < N; ++i) val[i] = 0; }
	void Add(int i, int x) { ++i;  while (i <= N) { val[i] += x; i += i & -i; } }
	int Sum(int i) { int s = 0; while (i > 0) { s += val[i]; i -= i & -i; } return s; }
	int Query(int L, int R) { return Sum(R) - Sum(L); }
};

int main()
{
	int a, b;
	scanf("%d%d", &a, &b);
	printf("%d\n", a*b);
	return 0;
}

Submission Info

Compile Error

./Main.cpp: In function ‘int main()’:
./Main.cpp:274:23: warning: ignoring return value of ‘int scanf(const char*, ...)’, declared with attribute warn_unused_result [-Wunused-result]
  scanf("%d%d", &a, &b);
                       ^

Judge Result