text
stringlengths 49
983k
|
|---|
//Solution for aoj:0537 Bingo
#include<iostream>
#include<algorithm>
#include<vector>
#include<set>
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
using namespace std;
const int surplus = 100000;
int N, ans;
int b[2][2001][3001];
int main(){
int n, m, s;
while (cin >> n >> m >> s){
if (!n&&!m&&!s)
return 0;
ans = 0;
N = n*n;
FOR(i, 1, m + 1)
b[0][i][i] = 1;
for (int i = 2; i < N + 1; i++){
for (int j = 1; j < m; j++){
for (int k = j; k < s; k++){
b[1][j + 1][k + 1] = b[1][j][k] + b[0][j][k - j];
b[1][j + 1][k + 1] %= surplus;
if (i == N&&k + 1 == s){
ans += b[1][j + 1][k + 1];
}
}
}
FOR(j, 1, m){
FOR(k, 1, s){
b[0][j][k] = b[1][j][k];
if (i == N)
b[0][j][k] = 0;
}
}
}
cout << ans%surplus << endl;
}
}
|
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <string>
#include <cmath>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
using namespace std;
void solve(int n,int m,int s){
int dp[50][3010]={0};
dp[0][0]=1;
for(int i=1;i<=m;i++){
for(int j=n*n-1;j>=0;j--){
for(int k=0;k<=s-i;k++){
dp[j+1][k+i]=(dp[j+1][k+i]+dp[j][k])%100000;
}
}
}
printf("%d\n",dp[n*n][s]%100000);
return;
}
int main(){
int n,m,s;
while(1){
scanf("%d%d%d",&n,&m,&s);
if(n+m+s==0) break;
solve(n,m,s);
}
return 0;
}
|
#include <iostream>
#include <string.h>
using namespace std;
int dp[50][3001];
void solve()
{
int N, M, S;
while(cin >> N >> M >> S, N || M || S)
{
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for (int i = 1; i <= M; ++i)
{
for (int j = N * N; j > 0; --j)
{
for (int k = S; k >= i; --k)
{
dp[j][k] = (dp[j][k] + dp[j-1][k-i]) % 100000;
}
}
}
cout << dp[N * N][S] << endl;
}
}
int main()
{
solve();
return(0);
}
|
#include <iostream>
#include <cstring>
using namespace std;
const int mod = 100000;
int main(){
int n,m,s;
int dp[50][3001];
while(cin>>n>>m>>s,n){
memset(dp,0,sizeof(dp));
dp[0][0]=1;
for(int i=1;i<=m;++i){
for(int j=n*n-1;j>=0;--j){
for(int k=0;k<=s-i;++k){
dp[j+1][k+i] +=dp[j][k];
dp[j+1][k+i] %= mod;
}
}
}
cout<<dp[n*n][s]<<endl;
}
return 0;
}
|
#include <iostream>
#include <vector>
#define repeat(i,n) for (int i = 0; (i) < (n); ++(i))
#define repeat_reverse(i,n) for (int i = (n)-1; (i) >= 0; --(i))
using namespace std;
const int mod = 100000;
int main() {
while (true) {
int n, m, s; cin >> n >> m >> s;
if (n == 0 and m == 0 and s == 0) break;
vector<vector<int> > dp(n*n+1, vector<int>(s+1));
dp[0][0] = 1;
repeat (i,m) {
repeat_reverse (j,n*n) {
repeat (k,s-i) {
dp[j+1][k+(i+1)] += dp[j][k];
dp[j+1][k+(i+1)] %= mod;
}
}
}
cout << dp[n*n][s] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define repl(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define rep(i,n) repl(i,0,n)
#define mp(a,b) make_pair((a),(b))
#define pb(a) push_back((a))
#define all(x) (x).begin(),(x).end()
#define uniq(x) sort(all(x)),(x).erase(unique(all(x)),end(x))
#define fi first
#define se second
#define dbg(x) cout<<#x" = "<<((x))<<endl
template<class T,class U> ostream& operator<<(ostream& o, const pair<T,U> &p){o<<"("<<p.fi<<","<<p.se<<")";return o;}
template<class T> ostream& operator<<(ostream& o, const vector<T> &v){o<<"[";for(T t:v){o<<t<<",";}o<<"]";return o;}
#define INF 2147483600
#define MOD 100000
int solve(int n, int m, int s){
vector<vector<int>> dp(n*n+1, vector<int>(s+1, 0));
dp[0][0] = 1;
repl(i,1,m+1){
vector<vector<int>> nxt(n*n+1, vector<int>(s+1, 0));
rep(j,n*n+1) rep(k,s+1) if(dp[j][k]>0){
(nxt[j][k] += dp[j][k])%=MOD;
if(j+1<=n*n && k+i<=s) (nxt[j+1][k+i] += dp[j][k]) %= MOD;
}
swap(dp, nxt);
}
return dp[n*n][s];
}
int main(){
int n,m,s;
while(cin>>n>>m>>s, n){
cout << solve(n,m,s) << endl;
}
return 0;
}
|
#include <iostream>
#include <queue>
#include <algorithm>
using namespace std;
int dp[2][55][3005];
int n,m,s;
int main(void){
while(1){
cin>>n>>m>>s;
if(!n&&!m&&!s)break;
n*=n;
for(int i=0;i<=n;i++){
for(int j=0;j<=s;j++){
dp[0][i][j]=0;
dp[1][i][j]=0;
}
}
dp[0][0][0]=1;
for(int i=1;i<=m;i++){
for(int j=0;j<=n;j++){
for(int k=0;k<=s;k++){
dp[i%2][j][k]=dp[(i+1)%2][j][k];
if(k-i>=0&&j>0)dp[i%2][j][k]=(dp[(i+1)%2][j-1][k-i]+dp[i%2][j][k])%100000;
}
}
}
cout<<dp[m%2][n][s]<<endl;
}
}
|
#include <cstdio>
#include <cstring>
int dp[50][3001];
int main() {
int N,M,S;
while(scanf("%d %d %d",&N,&M,&S),N) {
memset(dp,0,sizeof(dp));
dp[0][0]=1;
for(int m=1;m<=M;m++)for(int k=N*N;k>=1;k--)for(int s=m;s<=S;s++) {
dp[k][s]+=dp[k-1][s-m];
if(dp[k][s]>100000)dp[k][s]-=100000;
}
printf("%d\n",dp[N*N][S]);
}
}
|
#include <vector>
#include <list>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <bitset>
#include <algorithm>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <complex>
#define FOR(i,b,n) for(int i=b;i<n;i++)
#define RFOR(i,b,n) for(int i=n-1;i>=b;i--)
#define CLR(mat) memset(mat, 0, sizeof(mat))
#define NCLR(mat) memset(mat, -1, sizeof(mat))
using namespace std;
typedef pair<int,int> paii;
typedef long long ll;
int n, m, s;
int dp[100][5000];
int solve()
{
CLR(dp);
dp[0][0] = 1;
FOR(i, 1, m+1)
RFOR(j, 1, n*n+1)
FOR(k, i, s+1)
{
dp[j][k] += dp[j-1][k-i];
if(dp[j][k] >= 100000)
dp[j][k] = dp[j][k]%100000;
}
return dp[n*n][s];
}
int main()
{
while(cin >> n >> m >> s, (n||m||s))
{
cout << solve() << endl;
}
return 0;
}
|
#include<cstdio>
#include<algorithm>
using namespace std;
#define rep(i,n) for(i=0;i<n;i++)
#define reps(i,n) for(i=1;i<=n;i++)
int dp[50][2][3001];
int main(){
int n,m,s,nn,st,i,j,k;
int t1=0,t2=1;
while(1){
scanf("%d%d%d",&n,&m,&s);
if(n==0)break;
t1=0;
t2=1;
n*=n;
rep(i,50)rep(j,2)rep(k,s+1)dp[i][j][k]=0;
dp[0][0][0]=1;
reps(j,m){
dp[0][t2][0]=1;
reps(i,n){
nn=i;
st=(nn*(nn+1))/2;
for(k=st-1;k<s+1;k++){
dp[i][t2][k]=0;
if(k-j>=0){
dp[i][t2][k]+=dp[i-1][t1][k-j];
}
dp[i][t2][k]+=dp[i][t1][k];
if(dp[i][t2][k]<0)puts("AAAAAAA");
dp[i][t2][k]%=100000;
}
/*
if(i<9&&j<9){
printf("%d %d\n",i,j);
for(int k=0;k<50;k++){
printf("%d ",dp[i][t2][k]);
}puts("");
}*/
}
swap(t1,t2);
}
printf("%d\n",dp[n][t1][s]);
}
}
|
#include <iostream>
using namespace std;
int dp[55][3005];
int n,m,s,i,j,k;
int main(void){
while(1){
cin>>n>>m>>s;
if(!n)break;
n*=n;
for(i=0;i<=n;i++)for(j=0;j<=s;j++)dp[i][j]=0;
dp[0][0]=1;
for(i=1;i<=m;i++)for(j=n;j>0;j--)for(k=i;k<=s;k++)dp[j][k]=(dp[j-1][k-i]+dp[j][k])%100000;
cout<<dp[n][s]<<endl;
}
}
|
#include <bits/stdc++.h>
#define PB push_back
#define MP make_pair
#define REP(i,n) for (int i=0;i<(n);i++)
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define ALL(a) (a).begin(),(a).end()
using namespace std;
typedef pair<int,int> P;
typedef long long ll;
const int INF=1e9;
const int mod=100000;
int dp[2][3010][50];
int n,m,s;
int main(){
while(1){
cin>>n>>m>>s;
if(n==0&&m==0&&s==0)break;
memset(dp,0,sizeof(dp));
dp[0][0][0]=1;
for(int i=1;i<=m;i++){
REP(j,3010)REP(k,50)dp[i&1][j][k]=dp[(i-1)&1][j][k];
for(int j=0;j+i<=s;j++){
for(int k=0;k<n*n;k++){
if(dp[(i-1)&1][j][k]>=1){
}
dp[i&1][j+i][k+1]+=dp[(i-1)&1][j][k];
dp[i&1][j+i][k+1]%=mod;
}
}
}
cout<<dp[m&1][s][n*n]%mod<<endl;
}
}
|
#include <cstdio>
#include <string.h>
using namespace std;
int n, m, s, ans;
int dp[2][2001][3001];
int main(){
while(scanf("%d%d%d", &n, &m, &s) && n && m && s){
for(int i = 1; i <= m; i++)
dp[0][i][i] = 1;
for(int i = 2; i <= n * n; i++){
for(int j = 1; j < m; j++){
for(int k = j; k < s; k++){
dp[1][j + 1][k + 1] += dp[1][j][k];
dp[1][j + 1][k + 1] += dp[0][j][k - j];
dp[1][j + 1][k + 1] %= 100000;
}
}
for(int j = 1; j <= m; j++){
for(int k = 1; k <= s; k++){
dp[0][j][k] = dp[1][j][k];
dp[1][j][k] = 0;
}
}
}
for(int i = 1; i <= m; i++){
ans += dp[0][i][s];
ans %= 100000;
}
printf("%d\n", ans);
memset(dp, 0, sizeof dp);
ans = 0;
}
return 0;
}
|
#include<iostream>
using namespace std;
#define rep(i, n) for (int i = 0; i < int(n); ++i)
int dp[50][3001];
const int MOD = 100000;
int main() {
while (true) {
int n, m, s;
cin >> n >> m >> s;
if (n == 0) break;
n = n * n;
rep (i, 50) rep (j, 3001) dp[i][j] = 0;
dp[0][0] = 1;
rep (i, m + 1) if (i > 0) for (int j = n; j > 0; --j) for (int k = i; k <= s; ++k) {
dp[j][k] += dp[j - 1][k - i];
dp[j][k] %= MOD;
}
cout << dp[n][s] << endl;
}
}
|
#include<stdio.h>
int main(){
int n,m,s,i,j,w=1e5;
while(scanf("%d%d%d",&n,&m,&s),n){
int d[51][3001]={};d[0][0]=1;
for(i=1;i<=n*n;i++)for(j=i;j<=s;j++){
int &x=d[i][j];x+=d[i-1][j-i]+d[i][j-i];
if(j-1-m>=0)x+=w-d[i-1][j-1-m];x%=w;
}printf("%d\n",d[n*n][s]);
}
return 0;
}
|
#include <iostream>
#include <vector>
#include <string>
#include <queue>
#include <algorithm>
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define FORE(i,a,b) for(int i=(a);i<=(b);i++)
#define REP(i,b) FOR(i,0,b)
using namespace std;
typedef long long ll;
int DP[2][2001][3001];
int main() {
int N,M,S;
while(cin >> N >> M >> S && N){
int sum=0;
REP(i,2)
REP(j,2001)
REP(k,3001)
DP[i][j][k]=0;
DP[0][0][0]=1;
N*=N;
FORE(i,1,N)
FORE(j,0,M)
FORE(k,0,S)
if(j<=k && j)
DP[i%2][j][k]=(DP[i%2][j-1][k-1]+DP[(i+1)%2][j-1][k-j])%100000;
else
DP[i%2][j][k]=0;
FORE(i,1,M)
sum=(sum+DP[N%2][i][S])%100000;
cout << sum%100000 << endl;
}
// your code goes here
return 0;
}
|
#include <vector>
#include <iostream>
using namespace std;
const int mod = 100000;
int N, M, S;
int main() {
while (cin >> N >> M >> S, N) {
N *= N;
M -= N;
S -= N * (N + 1) / 2;
vector<vector<int> > dp(M + 1, vector<int>(S + 1, 0));
dp[0][0] = 1;
for (int i = 0; i < N; i++) {
vector<vector<int> > dp2(M + 1, vector<int>(S + 1, 0));
dp2[0][0] = 1;
for (int j = 1; j <= M; j++) {
for (int k = j; k <= S; k++) {
dp2[j][k] = dp[j][k - j];
if (j >= 1) {
dp2[j][k] += dp2[j - 1][k - 1];
if (dp2[j][k] >= mod) dp2[j][k] -= mod;
}
}
}
dp = dp2;
}
int ret = 0;
for (int i = 0; i <= M; i++) {
ret += dp[i][S];
if (ret >= mod) ret -= mod;
}
cout << ret << endl;
}
return 0;
}
|
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <cassert>
#include <iostream>
#include <cctype>
#include <sstream>
#include <string>
#include <list>
#include <vector>
#include <queue>
#include <set>
#include <stack>
#include <map>
#include <utility>
#include <numeric>
#include <algorithm>
#include <iterator>
#include <bitset>
#include <complex>
#include <fstream>
using namespace std;
typedef long long ll;
const double EPS = 1e-9;
typedef vector<int> vint;
typedef pair<int, int> pint;
#define rep(i, n) REP(i, 0, n)
#define ALL(v) v.begin(), v.end()
#define MSG(a) cout << #a << " " << a << endl;
#define REP(i, x, n) for(int i = x; i < n; i++)
template<class T> T RoundOff(T a){ return int(a+.5-(a<0)); }
template<class T, class C> void chmax(T& a, C b){ if(a < b) a = b; }
template<class T, class C> void chmin(T& a, C b){ if(b < a) a = b; }
template<class T, class C> pair<T, C> mp(T a, C b){ return make_pair(a, b); }
const int MOD = 100000;
int n, m, s;
int dp[50][3005]; // dp[Iðµ½Â][Ýv]ð½·gÝí¹Ì
int main()
{
while(cin >> n >> m >> s && n)
{
memset(dp,0,sizeof(dp));
dp[0][0]=1;
for(int i = 1; i <= m; i++)
{
for (int j = n * n; 0 < j; j--)
{
for(int k = s; i <= k; k--)
{
(dp[j][k] += dp[j - 1][k - i]) %= MOD;
}
}
}
cout << dp[n * n][s] << endl;
}
}
|
#include<map>
#include<set>
#include<list>
#include<cmath>
#include<queue>
#include<stack>
#include<cstdio>
#include<string>
#include<vector>
#include<complex>
#include<cstdlib>
#include<cstring>
#include<numeric>
#include<sstream>
#include<iostream>
#include<algorithm>
#include<functional>
#define mp make_pair
#define pb push_back
#define all(x) (x).begin(),(x).end()
#define rep(i,n) for(int i=0;i<(n);i++)
#define REP(i,b,n) for(int i=b;i<n;i++)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<vb> vvb;
typedef vector<vi> vvi;
typedef pair<int,int> pii;
const int INF=1<<29;
const double EPS=1e-9;
const int dx[]={1,0,-1,0},dy[]={0,-1,0,1};
int N,M,S;
const int MOD =100000;
ll dp[3010][51];
int main(){
while(cin>>N>>M>>S,N||M||S){
memset(dp,0,sizeof(dp));
dp[0][0] = 1;
for(int i =1;i <=M;i++){
for(int j =N*N;j >=1;j--){
for(int k = 1;k <=S;k++){
if(k-i>=0){
dp[k][j]=(dp[k][j]+dp[k-i][j-1])%MOD;
}
}
}
}
cout <<dp[S][N*N]<<endl;
}
return 0;
}
|
#include<map>
#include<set>
#include<list>
#include<cmath>
#include<queue>
#include<stack>
#include<cstdio>
#include<string>
#include<vector>
#include<complex>
#include<cstdlib>
#include<cstring>
#include<numeric>
#include<sstream>
#include<iostream>
#include<algorithm>
#include<functional>
#define mp make_pair
#define pb push_back
#define all(x) (x).begin(),(x).end()
#define rep(i,n) for(int i=0;i<(n);i++)
#define REP(i,b,n) for(int i=b;i<n;i++)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<vb> vvb;
typedef vector<vi> vvi;
typedef pair<int,int> pii;
const int INF=1<<29;
const double EPS=1e-9;
const int dx[]={1,0,-1,0},dy[]={0,-1,0,1};
int N,M,S;
const int MOD =100000;
ll dp[3010][51];
int main(){
while(cin>>N>>M>>S,N||M||S){
memset(dp,0,sizeof(dp));
dp[0][0] = 1;
for(int i =1;i <=M;i++){
for(int j =N*N;j >=1;j--){
for(int k = i;k <=S;k++){
if(k-i>=0){
dp[k][j]=(dp[k][j]+dp[k-i][j-1])%MOD;
}
}
}
}
cout <<dp[S][N*N]<<endl;
}
return 0;
}
|
#include <iostream>
#include <sstream>
#include <string>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cassert>
using namespace std;
#define FOR(i,k,n) for(int i=(k); i<(int)(n); ++i)
#define REP(i,n) FOR(i,0,n)
#define FORIT(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
template<class T> void debug(T begin, T end){ for(T i = begin; i != end; ++i) cerr<<*i<<" "; cerr<<endl; }
inline bool valid(int x, int y, int W, int H){ return (x >= 0 && y >= 0 && x < W && y < H); }
typedef long long ll;
const int INF = 100000000;
const double EPS = 1e-8;
const int MOD = 100000;
int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
int main(){
int N, M, S;
while(cin >> N >> M >> S && N){
N *= N;
static int dp[2][3001][2001] = {};
dp[0][0][0] = 1;
for(int i = 0; i < N; i++){
for(int sum = 1; sum <= S; sum++){
for(int last = 1; last <= min(M, sum); last++){
dp[(i + 1) & 1][sum][last] = (dp[(i + 1) & 1][sum - 1][last - 1] + dp[i & 1][sum - last][last - 1]) % MOD;
}
}
memset(dp[i & 1], 0, sizeof(dp[i & 1]));
}
int ans = 0;
for(int last = 1; last <= M; last++) ans = (ans + dp[N & 1][S][last]) % MOD;
cout << ans << endl;
}
return 0;
}
|
#include<iostream>
using namespace std;
int d[51][3210],n,m,s,i,j,k;
int main(){
while(cin>>n>>m>>s&&n){
n*=n;
for(i=0;i<=n;i++)for(j=0;j<=s;j++)d[i][j]=0;d[0][0]=1;
for(k=1;k<=m;k++){
for(i=n;i;i--){
for(j=k;j<=s;j++){
d[i][j]=(d[i][j]+d[i-1][j-k])%100000;
}
}
}
cout<<d[n][s]<<endl;
}
return 0;
}
|
#include <cstdio>
#include <cstring>
int dp[50][3001];
int main() {
int n,m,s;
while(scanf("%d %d %d",&n,&m,&s),n) {
memset(dp,0,sizeof(dp));
dp[0][0]=1;
for(int i=1;i<=m;i++)
for(int j=n*n;j>=1;j--)
for(int k=i;k<=s;k++) {
dp[j][k]+=dp[j-1][k-i];
if(dp[j][k]>=100000)dp[j][k]-=100000;
}
printf("%d\n",dp[n*n][s]);
}
}
|
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
int dp[2][3001][50];
const int mod=100000;
int n,m,s;
int main(){
while(cin>>n>>m>>s&&(n|m|s)){
memset(dp,0,sizeof(dp));
for(int i=0;i<2;i++)dp[i][0][n*n]=1;
for(int i=m;i>=0;i--){
for(int j=0;j<=s;j++){
for(int k=n*n;k>=0;k--){
int cur=(i+1)%2;
int nxt=i%2;
int res=0;
if(k==n*n){
if(j==0)res=1;
else res=0;
}
else{
res+=dp[cur][j][k];
if(j-i>=0)res+=dp[cur][j-i][k+1];
}
dp[nxt][j][k]=res%mod;
}
}
}
cout<<dp[1][s][0]%mod<<endl;
}
return 0;
}
|
#define _USE_MATH_DEFINES
#define INF 0x3f3f3f3f
#include <iostream>
#include <cstdio>
#include <sstream>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
#include <map>
#include <string>
#include <cstring>
#include <set>
#include <deque>
#include <bitset>
#include <list>
#include <cctype>
#include <utility>
using namespace std;
typedef long long ll;
typedef pair <int,int> P;
typedef pair <int,P> PP;
static const double EPS = 1e-8;
static const int tx[] = {0,1,0,-1};
static const int ty[] = {-1,0,1,0};
int dp[3001][50];
const static int MOD = 100000;
int main(){
int bingo_card_size;
int upper_number;
int bingo_card_sum;
while(~scanf("%d %d %d",
&bingo_card_size,
&upper_number,
&bingo_card_sum)){
if(bingo_card_size == 0
&& upper_number == 0
&& bingo_card_sum== 0) break;
memset(dp,0,sizeof(dp));
dp[0][0] = 1;
for(int num=1;num<=upper_number;num++){
for(int sum=bingo_card_sum;sum-num>=0;sum--){
for(int filled_count=bingo_card_size*bingo_card_size;filled_count-1>=0;filled_count--){
dp[sum][filled_count] += dp[sum-num][filled_count-1];
dp[sum][filled_count] %= MOD;
}
}
}
printf("%d\n",dp[bingo_card_sum][bingo_card_size*bingo_card_size]);
}
}
|
#include <bits/stdc++.h>
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define RFOR(i,a,b) for(int i=(b) - 1;i>=(a);i--)
#define REP(i,n) for(int i=0;i<(n);i++)
#define RREP(i,n) for(int i=n-1;i>=0;i--)
#define PB push_back
#define INF (1<<29)
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(),(a).rend()
#define CLR(a) memset(a,0,sizeof(a))
const int dx[] = {-1,0,0,1},dy[] = {0,1,-1,0};
typedef long long int ll;
using namespace std;
int dp[50][5001];
int main(){
while(true){
int n,m,s;
cin >> n >> m >> s;
if(n == 0 && m == 0 && s == 0) break;
memset(dp,0,sizeof(dp));
dp[0][0] = 1;
FOR(j,1,m+1){
RREP(k,s){
RREP(i,n*n){
dp[i+1][k+j] = (dp[i+1][k+j] + dp[i][k])%100000 ;
}
}
}
int ans =0 ;
ans += dp[n*n][s];
cout << ans << endl;
}
return 0;
}
|
//AOJ0537 bingo
#include <iostream>
#include <algorithm>
#include <vector>
#define MOD 100000
using namespace std;
int main(){
int n,m,s;
/*int dp[2001][50][3001] = {};
dp[1][1][1] = 1;
dp[1][0][0] = 1;
for(int i = 2;i <= 2000;i++){
for(int j = 0;j <= 49;j++){
for(int k = 0;k <= 3000;k++){
if(j == 0) dp[i][j][0] = 1;
else if(k - i >= 0) dp[i][j][k] = (dp[i - 1][j][k] + dp[i - 1][j - 1][k - i]) % MOD;
else dp[i][j][k] = dp[i - 1][j][k];
}
}
}*/
while(1){
cin >> n >> m >> s;
if(!n) break;
int dp[2][50][3001] = {};
dp[1][1][1] = 1;
dp[1][0][0] = 1;
for(int i = 2;i <= m;i++){
for(int j = 0;j <= n * n;j++){
for(int k = 0;k <= s;k++){
if(j == 0) dp[i % 2][j][0] = 1;
else if(k - i >= 0) dp[i % 2][j][k] = (dp[(i + 1) % 2][j][k] + dp[(i + 1) % 2][j - 1][k - i]) % MOD;
else dp[i % 2][j][k] = dp[(i + 1) % 2][j][k];
}
}
}
cout << dp[m % 2][n * n][s] << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
#define range(i,a,b) for(int i = (a); i < (b); i++)
#define rep(i,b) for(int i = 0; i < (b); i++)
#define all(a) (a).begin(), (a).end()
#define show(x) cerr << #x << " = " << (x) << endl;
using namespace std;
const int M = 100000;
int main(){
int n, m, s;
while(cin >> n >> m >> s,n){
vector<vector<int>> cur(n * n + 1, vector<int>(s + 1,0));
cur[0][0] = 1;
range(i,1,m + 1){
for (int j = n * n; j > 0; j--) {
range(k,i,s + 1){
(cur[j][k] += cur[j - 1][k - i]) %= M;
}
}
}
cout << cur[n * n][s] << endl;
}
}
|
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <math.h>
#include <assert.h>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
static const double EPS = 1e-9;
static const double PI = acos(-1.0);
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, n) for (int i = (s); i < (int)(n); i++)
#define FOREQ(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define FORIT(it, c) for (__typeof((c).begin())it = (c).begin(); it != (c).end(); it++)
#define MEMSET(v, h) memset((v), h, sizeof(v))
int n, m, s;
const int MOD = 100000;
int dp[2010][3010];
int main() {
while (scanf("%d %d %d", &n, &m, &s), n|m|s) {
MEMSET(dp, 0);
FOREQ(i, 0, m) {
dp[i][0] = 1;
}
REP(iter, n * n) {
dp[m][s] = 0;
for (int i = m; i >= 1; i--) {
int upper = s - i * (n * n - iter);
FOREQ(j, 0, upper) {
dp[i][j + i] = dp[i - 1][j];
}
memset(dp[i], 0, sizeof(int) * i);
}
FOREQ(i, 1, m) {
int upper = s + i - i * (n * n - iter);
FOREQ(j, 0, upper) {
dp[i][j] += dp[i - 1][j];
dp[i][j] %= MOD;
}
}
if (iter == 0) {
FOREQ(i, 0, m) {
dp[i][0] = 0;
}
}
}
printf("%d\n", dp[m][s]);
}
}
|
#include<iostream>
#include<cstring>
using namespace std;
int n,m,s;
int map[50][3001];
int main(void){
while(1){
cin >> n >> m >> s;
if(n==0 && m==0 && s==0)break;
memset(map,0,sizeof(map));
map[0][0]=1;
for(int i=1;i<=m;i++){
for(int j=n*n;j>=1;j--){
for(int k=i;k<=s;k++){
map[j][k]=(map[j][k]+map[j-1][k-i])%100000;
}
}
}
cout << map[n*n][s] << endl;
}
return 0;
}
|
#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<map>
#include<cstdio>
#include<cstring>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
#define REP(n) rep(i,n)
#define all(n) n.begin(),n.end()
const int MAXN = 7, MAXS = 3000 ;
int n, m, s;
unsigned int dp[MAXN * MAXN + 2][MAXS + 10], UB = 100000;
int main()
{
while(cin >> n >> m >> s && n)
{
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for(int i_m = 1; i_m <= m; i_m++)
for(int i_n = n * n; i_n > 0; i_n--)
for(int i_s = i_m; i_s <= s; i_s++)
dp[i_n][i_s] = (dp[i_n][i_s] + dp[i_n - 1][i_s - i_m]) % UB;
cout << dp[n * n][s] << endl;
}
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <cstring>
constexpr int MOD=(int)1e5;
constexpr int MAX_S=3000;
int n,m,s;
int dp[50][MAX_S+1];
int main() {
while(std::cin>>n>>m>>s, n+m+s){
std::memset(dp,0,sizeof(dp));
dp[0][0]=1;
for(int i=1;i<=std::min(m,s);++i){
for(int j=n*n;j>0;--j){
for(int k=i;k<=s;++k)
dp[j][k]=(dp[j][k]+dp[j-1][k-i])%MOD;
}
}
std::cout<<dp[n*n][s]<<std::endl;
}
return 0;
}
|
#include<cstdio>
#include<cstring>
#define mod 100000
using namespace std;
int dp[50][3001];
int main()
{
int n,m,s;
while(scanf("%d%d%d",&n,&m,&s),n){
n*=n;
memset(dp,0,sizeof(dp));
dp[0][0]=1;
for(int i=1;i<=m;i++){
for(int j=n;j>0;j--){
for(int l=i;l<=s;l++){
dp[j][l]=(dp[j][l]+dp[j-1][l-i])%mod;
}
}
}
printf("%d\n",dp[n][s]);
}
return 0;
}
|
#include <cstdio>
#include <algorithm>
#pragma warning(disable: 4996)
#define MOD 100000
#define MAX_M 2000
#define MAX_S 3000
int N, M, S;
int dp[2][MAX_M + 1][MAX_S + 1];
int main()
{
while (true)
{
scanf("%d", &N);
scanf("%d", &M);
scanf("%d", &S);
if (N == 0 && M == 0 && S == 0) { break; }
for (int i = 0; i < M; i++)
{
for (int j = 0; j < S; j++)
{
if (i == j && i != 0 && j != 0)
{
dp[1][i][j] = 1;
}
else
{
dp[1][i][j] = 0;
}
}
}
for (int n = 2; n <= N * N; n++)
{
for (int i = 0; i < M; i++)
{
dp[n % 2][i][0] = 0;
}
for (int j = 0; j < S; j++)
{
dp[n % 2][0][j] = 0;
}
for (int i = 1; i <= M; i++)
{
for (int j = 1; j <= S; j++)
{
if (n % 2 == 0)
{
dp[0][i][j] = (dp[0][i - 1][j - 1] + (j >= i ? dp[1][i - 1][j - i] : 0)) % MOD;
}
else
{
dp[1][i][j] = (dp[1][i - 1][j - 1] + (j >= i ? dp[0][i - 1][j - i] : 0)) % MOD;
}
}
}
}
int sum = 0;
for (int i = 1; i <= M; i++)
{
if (N % 2 == 0)
{
sum += dp[0][i][S];
}
else
{
sum += dp[1][i][S];
}
sum %= MOD;
}
printf("%d\n", sum);
}
return 0;
}
|
//#define __USE_MINGW_ANSI_STDIO 0
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<ll> VL;
typedef vector<VL> VVL;
typedef pair<int, int> PII;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
#define IN(a, b, x) (a<=x&&x<b)
#define MP make_pair
#define PB push_back
const int INF = (1LL<<30);
const ll LLINF = (1LL<<60);
const double PI = 3.14159265359;
const double EPS = 1e-12;
const int MOD = 100000;
//#define int ll
template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <typename T> T &chmax(T &a, const T &b) { return a = max(a, b); }
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
int dp[50][3010];
signed main(void)
{
while(true) {
int n, m, s;
cin >> n >> m >> s;
if(!n) break;
n *= n;
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
// ??°??????????????§???????´????i
FOR(i, 1, m+1) {
// j???????????§??§????¨????k?????¨???????????????
for(int j=n; j>=1; --j) FOR(k, i, s+1) {
(dp[j][k] += dp[j-1][k-i]) %= MOD;
}
}
cout << dp[n][s] << endl;
}
return 0;
}
|
#include <iostream>
#include <algorithm>
using namespace std;
/*
1からmまでの数をn*n個重複しないように選び、合計がsになるパターンの数を求める。
ナップサック
*/
int n,m,s;
int dp[50][3001];
int main(){
while(cin>>n>>m>>s,n){
//初期化?
for(int i=0;i<50;i++)for(int j=0;j<=3000;j++)dp[i][j]=0;
dp[0][0]=1;
for(int i=1;i<=m;i++){
for(int j=n*n;j>=1;j--){
for(int k=i;k<=s;k++){
dp[j][k]=(dp[j][k]+dp[j-1][k-i])%100000;
}
}
}
//出力
cout<<dp[n*n][s]<<endl;
}
return 0;
}
|
#include <iostream>
using namespace std;
void solve(int N, int M, int S) {
int dp[2][M+1][S+1];
dp[0][0][0]=0;
dp[1][0][0]=0;
for(int j=1; j<=M; ++j) {
dp[0][j][0]=0;
dp[1][j][0]=0;
for(int k=1; k<=S; ++k) {
dp[1][j][k]=(k<=j?1:0);
dp[0][j][k]=0;
}
}
for(int i=2; i<=N*N; ++i) {
dp[i%2][0][0]=0;
for(int j=1; j<=M; ++j) {
for(int k=1; k<=S; ++k) {
if(i>j) dp[i%2][j][k]=0;
else if(k<i*(i+1)/2) dp[i%2][j][k]=0;
else if(k-j<=0) dp[i%2][j][k]=dp[i%2][j-1][k];
else dp[i%2][j][k]=dp[i%2][j-1][k]+dp[(i-1)%2][j-1][k-j];
dp[i%2][j][k]%=100000;
}
}
}
cout << dp[(N*N)%2][M][S] << endl;
return;
}
int main() {
int N,M,S;
while(true) {
cin >> N >> M >> S;
if(N==0 && M==0 && S==0) break;
solve(N,M,S);
}
return 0;
}
|
//びぃあいえぬじぃおぉ＝BINGO!!
#include <cstdio>
int main(void)
{
while (1){
int n, m, s;
scanf("%d%d%d", &n, &m, &s);
int dp[50][3001]={0};
if (n == 0) break;
dp[0][0] = 1;
for (int i = 1; i <= m; i++){
for (int j = n * n; j >= 1; j--){
for (int k = i; k <= s; k++){
dp[j][k] += dp[j - 1][k - i];
if (dp[j][k] >= 100000){
dp[j][k] -= 100000;
}
}
}
}
printf("%d\n", dp[n * n][s]);
}
return (0);
}
|
// http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0537
// status:
// tag: [DP]
#define SUBMIT
//#define DEBUG
#include <bits/stdc++.h>
using namespace std;
using ui64 = unsigned long long;
using i64 = long long;
const int MOD = 100000;
// dp[i][j] 場所iで今の合計がjになる組み合わせの数
int dp[7 * 7 + 1][3000 + 1];
int N, M, S;
// 1以上M以下の自然数のみを用いてSのN分割を求める
int solve(int N, int M, int S, int mod) {
// init
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for (int m = 1; m <= M; ++m) { // 使える自然数
for (int n = N * N; n >= 1; --n) { // 今の位置
for (int s = m; s <= S; ++s) { // 総和
dp[n][s] = (dp[n][s] + dp[n - 1][s - m]) % mod;
}
}
}
return dp[N * N][S];
}
int main() {
#ifdef SUBMIT
auto& stream = cin;
#else
stringstream stream(R"(3 9 45
3 100 50
5 50 685
0 0 0
)");
#endif
while (true) {
stream >> N >> M >> S;
if (N == 0 && M == 0 && S == 0) break;
auto ans = solve(N, M, S, MOD);
cout << ans << endl;
}
return 0;
}
|
#include<iostream>
#include<cstring>
using namespace std;
const int MOD = 100000;
int n, m, s;
int dp[2][2001][3001];
int main()
{
while(cin >> n >> m >> s && n && m && s){
memset(dp, 0, sizeof dp);
int ans = 0;
dp[0][0][0] = 1;
for(int i = 1; i <= n * n; i++){
for(int j = 1; j <= m; j++)
for(int k = j; k <= s; k++)
dp[i % 2][j][k] = (dp[i % 2][j - 1][k - 1] + dp[(i + 1) % 2][j - 1][k - j]) % MOD;
memset(dp[(i + 1) % 2], 0, sizeof dp[(i + 1) % 2]);
}
for(int i = 1; i <= m; i++)
ans = (ans + dp[n * n % 2][i][s]) % MOD;
cout << ans << endl;
}
return 0;
}
|
#include <stdio.h>
#include <string.h>
#include <array>
using namespace std;
int n, m, s;
array<array<array<int, 3001>, 2001>,2>memo;
int main()
{
for (;;)
{
scanf("%d %d %d",&n,&m,&s);
if (n == 0)break;
for (int i = 0; i <= n*n; ++i)
{
for (int j = 0; j <= m; ++j)
{
for (int k = 0; k <= s; ++k)
{
int ans = 0;
if (i == 0)
{
if (j == 0 && k == 0)ans = 1;
else ans = 0;
}
else
{
if (j <= 0 || k < j)
{
ans = 0;
}
else
{
ans = memo[(i - 1) % 2 ][j - 1][k - j] + memo[i % 2][j - 1][k - 1];
}
}
memo[i % 2][j][k] = ans % 100000;
}
}
}
int ans = 0;
for (int i = 0; i <= m; ++i)
{
ans += memo[(n*n) % 2][i][s];
ans %= 100000;
}
printf("%d\n", ans);
}
return 0;
}
|
#include <stdio.h>
#include <algorithm>
using namespace std;
int _now[50*3001];
int _next[50*3001];
int main(){
while(1){
int n,m,s;
scanf("%d%d%d",&n,&m,&s);
if(n==0&&m==0&&s==0)
break;
int* now = _now;
fill(now,now+(n*n+1)*(s+1),0);
int* next = _next;
fill(next,next+(n*n+1)*(s+1),0);
now[0] = 1;
for(int i=1;i<=m;i++){
for(int j=0;j<=n*n;j++){
for(int k=0;k<=s;k++){
if(k+i<=s && j < n*n){
next[(j+1)*(s+1)+k+i] += now[j*(s+1)+k];
if(next[(j+1)*(s+1)+k+i] >= 100000)
next[(j+1)*(s+1)+k+i] -= 100000;
}
next[j*(s+1)+k] += now[j*(s+1)+k];
if(next[j*(s+1)+k] >= 100000)
next[j*(s+1)+k] -= 100000;
now[j*(s+1)+k] = 0;
}
}
swap(now,next);
}
printf("%d\n",now[(n*n)*(s+1)+s]);
}
}
|
#include <iostream>
#include <cstring>
using namespace std;
int n,m,s;
int dp[50][3001];
int main() {
while(cin>>n>>m>>s, n|m|s) {
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
// ????????????
for (int i=1; i<=m; ++i)
for (int j=n*n; j>0; --j)
for (int k=s; k>=i; --k)
dp[j][k] = (dp[j][k] + dp[j-1][k-i])%100000;
cout<<dp[n*n][s]<<endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
int dp[10][55][3010] = {0};
int main()
{
int N,M,S;
while(scanf("%d%d%d",&N,&M,&S),N + M + S)
{
for(int i = 1; i < N * N + 1; i++)
{
for(int j = 1; j < S + 1; j++)
{
dp[0][i][j] = 0;
}
}
for(int i = 1; i < M + 1; i++)
{
for(int j = 1; j < N * N + 1; j++)
{
for(int k = 1; k < S + 1; k++)
{
dp[1][j][k] = 0;
if(j == 1)
{
dp[1][j][k] = dp[0][j][k];
if(i == k)dp[1][j][k]++;
}
else
{
dp[1][j][k] = dp[0][j][k];
if(k > i)dp[1][j][k] = (dp[1][j][k] + dp[0][j - 1][k - i]) % 100000;
}
}
}
for(int j = 1; j < N * N + 1; j++)
{
for(int k = 1; k < S + 1; k++)
{
dp[0][j][k] = dp[1][j][k];
dp[1][j][k] = 0;
}
}
}
printf("%d\n",dp[0][N * N][S]);
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,m,s;
while(scanf("%d %d %d",&n,&m,&s),n!=0&&m!=0&&s!=0){
int sum[50][3001] = {};
sum[0][0] = 1;
for(int i=1;i<=m;i++){
for(int j=min(i,n*n);j>0;j--){
for(int k=i;k<=s;k++){
sum[j][k] = (sum[j][k] + sum[j-1][k-i])%100000;
}
}
}
printf("%d\n",sum[n*n][s]);
}
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
#define dump(...) cout<<"# "<<#__VA_ARGS__<<'='<<(__VA_ARGS__)<<endl
#define repi(i,a,b) for(int i=int(a);i<int(b);i++)
#define peri(i,a,b) for(int i=int(b);i-->int(a);)
#define rep(i,n) repi(i,0,n)
#define per(i,n) peri(i,0,n)
#define all(c) begin(c),end(c)
#define mp make_pair
#define mt make_tuple
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<string> vs;
template<typename T1,typename T2>
ostream& operator<<(ostream& os,const pair<T1,T2>& p){
return os<<'('<<p.first<<','<<p.second<<')';
}
template<typename Tuple>
void print_tuple(ostream&,const Tuple&){}
template<typename Car,typename... Cdr,typename Tuple>
void print_tuple(ostream& os,const Tuple& t){
print_tuple<Cdr...>(os,t);
os<<(sizeof...(Cdr)?",":"")<<get<sizeof...(Cdr)>(t);
}
template<typename... Args>
ostream& operator<<(ostream& os,const tuple<Args...>& t){
print_tuple<Args...>(os<<'(',t);
return os<<')';
}
template<typename Ch,typename Tr,typename C,typename=decltype(begin(C()))>
basic_ostream<Ch,Tr>& operator<<(basic_ostream<Ch,Tr>& os,const C& c){
os<<'[';
for(auto i=begin(c);i!=end(c);++i)
os<<(i==begin(c)?"":" ")<<*i;
return os<<']';
}
constexpr int INF=1e9;
constexpr int MOD=1e9+7;
constexpr double EPS=1e-9;
struct UnionFind{
vi data;
UnionFind(int n):data(n,-1){}
int Find(int i){
return data[i]<0?i:(data[i]=Find(data[i]));
}
bool Unite(int a,int b){
a=Find(a),b=Find(b);
if(a==b) return false;
if(-data[a]<-data[b]) swap(a,b);
data[a]+=data[b];
data[b]=a;
return true;
}
int Size(int i){
return -data[Find(i)];
}
};
struct Edge{
int src,dst,weight;
Edge(){}
Edge(int s,int d,int w):src(s),dst(d),weight(w){}
};
typedef vector<vector<Edge>> Graph;
int main()
{
for(int n,m;cin>>n>>m && n|m;){
vector<Edge> es;
int neg=0;
rep(i,m){
int u,v,w; cin>>u>>v>>w;
if(w<=0) neg+=w;
else es.emplace_back(u,v,w);
}
m=es.size();
int res=INF;
{
UnionFind uf(n);
int cc=n;
rep(i,m)
cc-=uf.Unite(es[i].src,es[i].dst);
if(cc>=2) res=0;
}
{
rep(i,m){
vi use(m,1); use[i]=0;
UnionFind uf(n);
int cc=n;
rep(j,m) if(use[j])
cc-=uf.Unite(es[j].src,es[j].dst);
if(cc>=2) res=min(res,es[i].weight);
}
}
{
rep(i,m) repi(j,i+1,m){
vi use(m,1); use[i]=use[j]=0;
UnionFind uf(n);
int cc=n;
rep(k,m) if(use[k])
cc-=uf.Unite(es[k].src,es[k].dst);
if(cc>=2) res=min(res,es[i].weight+es[j].weight);
}
}
cout<<neg+res<<endl;
}
}
|
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cstring>
#include <cctype>
#include <algorithm>
#include <string>
#include <complex>
#include <list>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <sstream>
#include <numeric>
#include <functional>
#include <bitset>
#include <iomanip>
using namespace std;
#define INF (1<<29)
// math
#define Sq(x) ((x)*(x))
// container utility
#define ALL(x) (x).begin(), (x).end()
#define MP make_pair
#define PB push_back
#define EACH(it,c) for(__typeof((c).begin())it=(c).begin();it!=(c).end();it++)
// rep
#define REP(i,a,b) for(int i=a;i<b;i++)
#define rep(i,n) REP(i,0,n)
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
// typedef
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<PII> VII;
typedef vector<VI> VVI;
typedef long long ll;
// conversion
template<class T> inline string toStr(T a) { ostringstream oss; oss << a; return oss.str(); }
inline int toInt(string s) { return atoi(s.c_str()); }
// prime
bool isPrime(int a) { for(int i=2; i*i <=a; i++) if(a%i == 0) return false; return true; }
// !!! set MAX_L number !!!
#define MAX_L (1000001)
#define MAX_SQRT_B ((int)sqrt(INT_MAX)+1)
bool is_prime[MAX_L];
vector<bool> is_prime_small(MAX_SQRT_B);
void segment_sieve(ll a, ll b) {
for(int i=0; (ll)i*i < b; i++) is_prime_small[i] = true;
for(int i=0; i < b-a; i++) is_prime[i] = true;
if(a == 1) {
is_prime[0] = false;
}
is_prime_small[0] = is_prime_small[1] = false;
for(int i=2; (ll)i*i<b; i++) {
if(is_prime_small[i]) {
for(int j=2*i; (ll)j*j<b; j+=i) is_prime_small[j] = false;
for(ll j = max(2LL, (a+i-1)/i)*i; j<b; j+=i) is_prime[j-a] = false;
}
}
}
//////////////////////////////////////////////////////////////
struct Edge {
int to, cost, id;
Edge(int t, int c, int i)
: to(t), cost(c), id(i) {}
};
#define MAX_E (200)
vector<Edge> es[MAX_E];
int N, M;
bool isConnected(int x) {
vector<bool> used(N);
vector<int> VEC;
VEC.PB(0); used[0] = 1;
int v = 0;
while(!VEC.empty()) {
vector<int> NEXT;
EACH(i, VEC) {
EACH(e, es[*i]) {
if(e->id != x && !used[e->to]) {
used[e->to] = 1;
NEXT.PB(e->to);
}
}
v ++;
}
VEC = NEXT;
}
return N == v;
}
int main() {
while( cin >> N >> M && (N|M) ) {
for(int i=0; i<MAX_E; i++) {
es[i].clear();
}
int base = 0;
int id = 0;
vector<int> cost;
for(int i=0; i<M; i++) {
int s, t, c;
cin >> s >> t >> c;
if(c <= 0) base += c;
else {
es[s].PB(Edge(t, c, id));
es[t].PB(Edge(s, c, id));
cost.PB(c);
id ++;
}
}
int E = id;
int ans = INF;
if(!isConnected(-1)) ans = 0;
for(int i=0; i<E; i++) {
if(!isConnected(i)) ans = min(ans, cost[i]);
}
for(int i=0; i<E-1; i++)
for(int j=i+1; j<E; j++)
ans = min(ans, cost[i]+cost[j]);
cout << base + ans << endl;
}
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cstring>
#include <cctype>
#include <algorithm>
#include <string>
#include <complex>
#include <list>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <sstream>
#include <numeric>
#include <functional>
#include <bitset>
#include <iomanip>
using namespace std;
#define INF (1<<29)
// math
#define Sq(x) ((x)*(x))
// container utility
#define ALL(x) (x).begin(), (x).end()
#define MP make_pair
#define PB push_back
#define EACH(it,c) for(__typeof((c).begin())it=(c).begin();it!=(c).end();it++)
// rep
#define REP(i,a,b) for(int i=a;i<b;i++)
#define rep(i,n) REP(i,0,n)
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
// typedef
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<PII> VII;
typedef vector<VI> VVI;
typedef long long ll;
// conversion
template<class T> inline string toStr(T a) { ostringstream oss; oss << a; return oss.str(); }
inline int toInt(string s) { return atoi(s.c_str()); }
// prime
bool isPrime(int a) { for(int i=2; i*i <=a; i++) if(a%i == 0) return false; return true; }
// !!! set MAX_L number !!!
#define MAX_L (1000001)
#define MAX_SQRT_B ((int)sqrt(INT_MAX)+1)
bool is_prime[MAX_L];
vector<bool> is_prime_small(MAX_SQRT_B);
void segment_sieve(ll a, ll b) {
for(int i=0; (ll)i*i < b; i++) is_prime_small[i] = true;
for(int i=0; i < b-a; i++) is_prime[i] = true;
if(a == 1) {
is_prime[0] = false;
}
is_prime_small[0] = is_prime_small[1] = false;
for(int i=2; (ll)i*i<b; i++) {
if(is_prime_small[i]) {
for(int j=2*i; (ll)j*j<b; j+=i) is_prime_small[j] = false;
for(ll j = max(2LL, (a+i-1)/i)*i; j<b; j+=i) is_prime[j-a] = false;
}
}
}
//////////////////////////////////////////////////////////////
struct Edge {
int to, cost, id;
Edge(int t, int c, int i)
: to(t), cost(c), id(i) {}
};
#define MAX_E (99)
vector<Edge> es[MAX_E];
int N, M;
bool isConnected(int x) {
vector<bool> used(N);
vector<int> VEC;
VEC.PB(0); used[0] = 1;
int v = 0;
while(!VEC.empty()) {
vector<int> NEXT;
EACH(i, VEC) {
EACH(e, es[*i]) {
if(e->id != x && !used[e->to]) {
used[e->to] = 1;
NEXT.PB(e->to);
}
}
v ++;
}
VEC = NEXT;
}
return N == v;
}
int main() {
while( cin >> N >> M && (N|M) ) {
for(int i=0; i<MAX_E; i++) {
es[i].clear();
}
int base = 0;
int id = 0;
vector<int> cost;
for(int i=0; i<M; i++) {
int s, t, c;
cin >> s >> t >> c;
if(c <= 0) base += c;
else {
es[s].PB(Edge(t, c, id));
es[t].PB(Edge(s, c, id));
cost.PB(c);
id ++;
}
}
int E = id;
int ans = INF;
if(!isConnected(-1)) ans = 0;
for(int i=0; i<E; i++) {
if(!isConnected(i)) ans = min(ans, cost[i]);
}
for(int i=0; i<E-1; i++)
for(int j=i+1; j<E; j++)
ans = min(ans, cost[i]+cost[j]);
cout << base + ans << endl;
}
return 0;
}
|
#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
using namespace std;
struct edge{
int u, v, cost;
edge(int u_, int v_, int cost_){
u = u_; v = v_; cost = cost_;
}
};
bool operator<(const edge &a, const edge &b){
return a.cost < b.cost;
}
// Union-Find
struct union_find{
vector<int> par, rank;
// テ」ツつウテ」ツδウテ」ツつケテ」ツδ暗」ツδゥテ」ツつッテ」ツつソテ」ツ?ァテ・ツ按敕ヲツ慊淌・ツ個?
union_find(int n){
par = vector<int>( n );
rank = vector<int>( n , 0 );
for(int i=0 ; i < n ; i++ ){
par[i] = i;
}
}
// x テ」ツ?ョ root テ」ツつ津ィツソツ氾」ツ??
int find(int x){
return ( par[x] == x )? x : (par[x] = find(par[x]) ) ;
}
// x テ」ツ?ィ y テ」ツ?ョテ・ツアツ榲」ツ?凖」ツつ凝ゥツ崢?・ツ青暗」ツつ津、ツスツオテ・ツ青暗」ツ?凖」ツつ?
void unite(int x, int y){
x = find(x);
y = find(y);
if( x == y ) return;
if( rank[x] < rank[y] ){
par[x] = y;
}else{
par[y] = x;
if( rank[x] == rank[y] )
rank[x]++;
}
}
// x テ」ツ?ィ y テ」ツ?古・ツ青古」ツ?佚ゥツ崢?・ツ青暗」ツ?ォテ・ツアツ榲」ツ?凖」ツつ凝」ツ?凝」ツ?ゥテ」ツ??」ツ??
bool same(int x, int y){
return find(x) == find(y);
}
// テゥツ崢?・ツ青暗」ツ?ョテヲツ閉ーテ」ツつ津ィツソツ氾」ツ??
int size(){
set<int> s;
for(int i=0 ; i < par.size() ; i++ ){
s.insert( this->find(i) );
}
return s.size();
}
};
typedef pair<int,int> P;
const int INF = 1e+8;
const int MAX_V = 101;
int N, M;
int connect(const vector<set<int> > &G, vector<edge> e = vector<edge>() ){
union_find uf(N);
for(int u=0 ; u < N ; u++ ){
set<int> s = G[u];
for(set<int>::iterator it = s.begin() ; it != s.end() ; ++it ){
int v = *it;
bool flag = true;
for(int k=0 ; k < e.size() ; k++ ){
if( e[k].u == u && e[k].v == v ) flag = false;
if( e[k].u == v && e[k].v == u ) flag = false;
}
if( flag ) uf.unite(u, v);
}
}
return uf.size();
}
int main(){
// テ・ツ?・テ・ツ環?
while( cin >> N >> M , N || M ){
vector<set<int> > G(MAX_V);
vector<edge> e;
int ans = 0;
for(int i=0 ; i < M ; i++ ){
int x, y, c;
cin >> x >> y >> c;
if( c <= 0 ){ // テ」ツつウテ」ツつケテ」ツδ暗」ツ?古ィツイツ?」ツ?ョテ」ツつづ」ツ?ョテ」ツ?ッテ」ツ?凖」ツ?ケテ」ツ?ヲテ・ツ渉姪」ツつ甘ゥツ卍、テ」ツ??
ans += c;
}else{
e.push_back( edge(x, y, c) );
G[x].insert(y);
G[y].insert(x);
}
}
if( 2 <= connect(G) ){ // テゥツ?」テァツオツ静ヲツ按静・ツ按?」ツ??テ・ツ?凝、ツサツ・テ、ツクツ甘」ツ?ョテ」ツ?ィテ」ツ??
cout << ans << endl;
}else{ // テゥツ?」テァツオツ静ヲツ按静・ツ按?」ツ??テ・ツ?凝」ツ?ョテ」ツ?ィテ」ツ??
bool flag = false;
int sum_cost = ans;
// テ」ツつィテ」ツδε」ツつクテ」ツつ津ゥツォツ佚」ツ??テ・ツ?凝・ツ渉姪」ツつ甘ゥツ卍、テ」ツ??」ツ?淌」ツ?ィテ」ツ?催」ツつ津・ツ?ィテゥツδィティツゥツヲテ」ツ??
for(int i=0 ; i < e.size() ; i++ ){
vector<edge> e_;
e_.push_back( e[i] );
if( 2 <= connect(G, e_) ){
if( !flag ){
flag = true;
ans = sum_cost + e[i].cost;
}else{
ans = min(ans, sum_cost + e[i].cost);
}
}else{
for(int j=i+1 ; j < e.size() ; j++ ){
e_.push_back( e[j] );
if( 2 <= connect(G, e_) ){
if( !flag ){
flag = true;
ans = sum_cost + e[i].cost + e[j].cost;
}else{
ans = min(ans, sum_cost + e[i].cost + e[j].cost);
}
}
}
}
}
cout << ans << endl;
}
}
}
|
#define _USE_MATH_DEFINES
#define INF 100000000
#include <iostream>
#include <sstream>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
#include <map>
#include <string>
#include <cstring>
#include <set>
#include <deque>
#include <bitset>
#include <list>
#include <cstdio>
using namespace std;
typedef long long ll;
typedef pair <int,int> P;
typedef pair <int,P> PP;
static const double EPS = 1e-8;
const int tx[] = {0,1,0,-1};
const int ty[] = {-1,0,1,0};
struct Node {
int to;
int idx;
int flow;
Node(int to,int idx,int flow) :
to(to),idx(idx),flow(flow) {}
};
class FordFulkerson {
private:
vector<Node>* _graph;
bool* _used;
int _size;
int dfs(int src,int flow,int sink){
if(src == sink) return flow;
_used[src] = true;
for(int i= 0;i < _graph[src].size();i++){
Node& e = _graph[src][i];
if(_used[e.to]) continue;
if(e.flow <= 0) continue;
int d = dfs(e.to,min(flow,e.flow),sink);
if(d <= 0) continue;
Node& rev_e = _graph[e.to][e.idx];
e.flow -= d;
rev_e.flow += d;
return d;
}
return 0;
}
public:
FordFulkerson(int n) {
_size = n;
_graph = new vector<Node>[_size];
_used = new bool[_size];
}
FordFulkerson(const FordFulkerson& f){
_size = f.size();
_graph = new vector<Node>[_size];
_used = new bool[_size];
fill((bool*)_used,(bool*)_used + _size,false);
for(int i = 0; i < f.size(); i++){
for(int j = 0; j < f.graph()[i].size(); j++){
_graph[i].push_back(f.graph()[i][j]);
}
}
}
void add_edge(int from,int to,int flow) {
_graph[from].push_back(Node(to,_graph[to].size(),flow));
_graph[to].push_back(Node(from,_graph[from].size()-1,flow));
}
int compute_maxflow(int src,int sink){
int res = 0;
while(true){
fill((bool*)_used,(bool*)_used + _size,false);
int tmp = dfs(src,numeric_limits<int>::max(),sink);
if(tmp == 0) break;
res += tmp;
}
return res;
}
int size() const{
return _size;
}
vector<Node>* graph() const{
return _graph;
}
};
int main(){
int num_of_houses;
int num_of_paths;
while(~scanf("%d %d",&num_of_houses,&num_of_paths)){
if(num_of_houses == 0 && num_of_paths == 0) break;
FordFulkerson ff(num_of_houses);
int bonus = 0;
for(int path_i = 0; path_i < num_of_paths; path_i++){
int from,to;
int cost;
scanf("%d %d %d",&from,&to,&cost);
if(cost < 0) bonus += cost;
ff.add_edge(from,to,max(0,cost));
}
int res = numeric_limits<int>::max();
for(int house_i = 1; house_i< num_of_houses; house_i++){
FordFulkerson tmp(ff);
res = min(res,tmp.compute_maxflow(0,house_i));
}
printf("%d\n",bonus + res);
}
}
|
#include<iostream>
#include<vector>
#include<algorithm>
#include<climits>
#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
#define IINF (INT_MAX)
#define MAX 200
using namespace std;
struct Data{
int from,to,cost,index;
Data(int from=-1,int to=-1,int cost=-1,int index=-1):from(from),to(to),cost(cost),index(index){}
};
int V,E;
vector<Data> G[MAX];
bool visited[MAX];
void isconnect(int cur,int &counter,int *ban){
if(visited[cur])return;
visited[cur] = true;
counter++;
rep(i,G[cur].size()){
if( ban[0] == G[cur][i].index || ban[1] == G[cur][i].index ) continue;
isconnect(G[cur][i].to,counter,ban);
}
}
int main(){
while(cin >> V >> E,V|E){
Data *input = new Data[E];
int mincost = IINF,coef = 0;
rep(i,V)G[i].clear();
rep(i,E){
cin >> input[i].from >> input[i].to >> input[i].cost;
input[i].index = i;
if( input[i].cost < 0 ) coef += input[i].cost;
else {
G[input[i].from].push_back(input[i]);
G[input[i].to].push_back(Data(input[i].to,input[i].from,input[i].cost,input[i].index));
}
}
int counter = 0;
int ban[2] = {-1,-1};
rep(i,V)visited[i] = false;
isconnect(0,counter,ban);
if(counter != V)mincost = min(mincost,coef);
rep(i,E){
if( input[i].cost < 0 ) continue;
rep(j,E){
if( input[j].cost < 0 ) continue;
rep(k,V)visited[k] = false;
ban[0] = i, ban[1] = j;
counter = 0;
isconnect(0,counter,ban);
if( counter != V )mincost = min(mincost,coef+input[i].cost+((i==j)?0:input[j].cost));
}
}
cout << mincost << endl;
delete [] input;
}
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <cmath>
#include <string>
#include <cctype>
#include <map>
#include <iomanip>
using namespace std;
#define eps 1e-8
#define pi acos(-1.0)
#define inf 1<<30
#define linf 1LL<<60
#define pb push_back
#define lc(x) (x << 1)
#define rc(x) (x << 1 | 1)
#define lowbit(x) (x & (-x))
#define ll long long
#define maxn 110
int maz[maxn][maxn];
int n,m;
int stoer_wagner(int n){
bool vis[maxn];
int node[maxn],dis[maxn];
int maxj,prev;
int ans=inf;
memset(dis,0,sizeof(dis));
for (int i=0; i<n; i++)node[i]=i;
while (n>1) {
prev=0;
maxj=1;
memset(vis,false,sizeof(vis));
vis[node[0]]=true;
for (int i=1; i<n; i++) {
dis[node[i]]=maz[node[0]][node[i]];
if (dis[node[i]]>dis[node[maxj]])
maxj=i;
}
for (int i=1; i<n; i++) {
if (i==n-1) { //蜿ェ蜑ゥ譛?錘荳?クェ轤ケ蟆ア蠑?ァ句粋蟷カ轤ケ
ans=(dis[node[maxj]]<ans?dis[node[maxj]]:ans);
for (int k=0; k<n; k++) {//蜷亥ケカ轤ケ?梧峩譁ー霎ケ譚??邉サ
maz[node[k]][node[prev]]+=maz[node[k]][node[maxj]];
maz[node[prev]][node[k]]=maz[node[k]][node[prev]];
}
node[maxj]=node[--n];//郛ゥ轤ケ
}
prev=maxj;
vis[node[maxj]]=true;
maxj=-1;
for (int k=1; k<n; k++) {
if(!vis[node[k]]) {
dis[node[k]]+=maz[node[prev]][node[k]];
if(maxj==-1 || dis[node[k]]>dis[node[maxj]])
maxj=k;
}
}
}
}
return ans;
}
int main(){
while(~scanf("%d%d",&n,&m)){
if(n==0&&m==0) break;
memset(maz,0,sizeof(maz));
int a,b,c,res=0;
for (int i=0; i<m; i++) {
scanf("%d%d%d",&a,&b,&c);
if(c<0){
res+=c;
continue;
}
maz[a][b]+=c;
maz[b][a]+=c;
}
printf("%d\n",stoer_wagner(n)+res);
}
return 0;
}
|
//58
#include<iostream>
#include<vector>
#include<set>
using namespace std;
struct E{
int x,y,c;
};
int n,m;
int p[100];
int find(int x){
return p[x]==x?x:p[x]=find(p[x]);
}
void unite(int a,int b){
p[find(a)]=find(b);
}
int ds(vector<E> v){
for(int i=0;i<n;i++){
p[i]=i;
}
for(int i=0;i<v.size();i++){
unite(v[i].x,v[i].y);
}
set<int> r;
for(int i=0;i<n;i++){
r.insert(find(i));
}
return r.size();
}
int rec(vector<E> v,int d,int c){
if(d>2){
return 1<<30;
}else{
if(ds(v)>1){
return c;
}else{
int m=1<<30;
for(int i=0;i<v.size();i++){
vector<E> nv=v;
int nc=c+nv[i].c;
nv.erase(nv.begin()+i);
m=min(m,rec(nv,d+1,nc));
}
return m;
}
}
}
int main(){
while(cin>>n>>m,n|m){
int s=0;
vector<E> v;
while(m--){
int x,y,c;
cin>>x>>y>>c;
if(c>0){
E e={x,y,c};
v.push_back(e);
}else{
s+=c;
}
}
cout<<rec(v,0,s)<<endl;
}
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cstring>
#include <cctype>
#include <algorithm>
#include <string>
#include <complex>
#include <list>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <sstream>
#include <numeric>
#include <functional>
#include <bitset>
#include <iomanip>
using namespace std;
#define INF (1<<29)
// math
#define Sq(x) ((x)*(x))
// container utility
#define ALL(x) (x).begin(), (x).end()
#define MP make_pair
#define PB push_back
#define EACH(it,c) for(__typeof((c).begin())it=(c).begin();it!=(c).end();it++)
// rep
#define REP(i,a,b) for(int i=a;i<b;i++)
#define rep(i,n) REP(i,0,n)
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
// typedef
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<PII> VII;
typedef vector<VI> VVI;
typedef long long ll;
// conversion
template<class T> inline string toStr(T a) { ostringstream oss; oss << a; return oss.str(); }
inline int toInt(string s) { return atoi(s.c_str()); }
// prime
bool isPrime(int a) { for(int i=2; i*i <=a; i++) if(a%i == 0) return false; return true; }
// !!! set MAX_L number !!!
#define MAX_L (1000001)
#define MAX_SQRT_B ((int)sqrt(INT_MAX)+1)
bool is_prime[MAX_L];
vector<bool> is_prime_small(MAX_SQRT_B);
void segment_sieve(ll a, ll b) {
for(int i=0; (ll)i*i < b; i++) is_prime_small[i] = true;
for(int i=0; i < b-a; i++) is_prime[i] = true;
if(a == 1) {
is_prime[0] = false;
}
is_prime_small[0] = is_prime_small[1] = false;
for(int i=2; (ll)i*i<b; i++) {
if(is_prime_small[i]) {
for(int j=2*i; (ll)j*j<b; j+=i) is_prime_small[j] = false;
for(ll j = max(2LL, (a+i-1)/i)*i; j<b; j+=i) is_prime[j-a] = false;
}
}
}
//////////////////////////////////////////////////////////////
struct Edge {
int to, cost, id;
Edge(int t, int c, int i)
: to(t), cost(c), id(i) {}
};
#define MAX_E (198)
vector<Edge> es[MAX_E];
int N, M;
bool isConnected(int x) {
vector<bool> used(N);
vector<int> VEC;
VEC.PB(0); used[0] = 1;
int v = 0;
while(!VEC.empty()) {
vector<int> NEXT;
EACH(i, VEC) {
EACH(e, es[*i]) {
if(e->id != x && !used[e->to]) {
used[e->to] = 1;
NEXT.PB(e->to);
}
}
v ++;
}
VEC = NEXT;
}
return N == v;
}
int main() {
while( cin >> N >> M && (N|M) ) {
for(int i=0; i<MAX_E; i++) {
es[i].clear();
}
int base = 0;
int id = 0;
vector<int> cost;
for(int i=0; i<M; i++) {
int s, t, c;
cin >> s >> t >> c;
if(c <= 0) base += c;
else {
es[s].PB(Edge(t, c, id));
es[t].PB(Edge(s, c, id));
cost.PB(c);
id ++;
}
}
int E = id;
int ans = INF;
if(!isConnected(-1)) ans = 0;
for(int i=0; i<E; i++) {
if(!isConnected(i)) ans = min(ans, cost[i]);
}
for(int i=0; i<E-1; i++)
for(int j=i+1; j<E; j++)
ans = min(ans, cost[i]+cost[j]);
cout << base + ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define MAX 110
#define INF INT_MAX
typedef pair<int, int> pii;
struct Edge {
int from, to, cost;
Edge(int from, int to, int cost) :
from(from), to(to), cost(cost) {}
};
int N, M;
vector<Edge> G[MAX], cycle;
int color[MAX];
void dfs(int v, vector<Edge> u)
{
color[v] = 0;
for(int i = 0; i < (int)G[v].size(); i++) {
Edge e = G[v][i];
int to = e.to;
u.push_back(e);
if (color[to] == -1) {
dfs(to, u);
} else if(color[to] == 0) {
cycle = u;
throw 0;
}
u.pop_back();
}
color[v] = 1;
}
bool is_cycle_detect()
{
vector<Edge> vec;
memset(color, -1, sizeof(color));
for (int i = 0; i < N; i++) {
try {
if (color[i] == -1) {
dfs(i, vec);
}
} catch (...) {
break;
}
vec.clear();
}
return (cycle.size() > 0);
}
void init()
{
cycle.clear();
for (int i = 0; i < MAX; i++) {
G[i].clear();
}
}
class Union_Find {
public:
int par[MAX], rank[MAX], size[MAX], gnum;
Union_Find(int N) {
gnum = N;
for (int i = 0; i < N; i++) {
par[i] = i;
rank[i] = 0;
size[i] = 1;
}
}
int find(int x)
{
if (par[x] == x) {
return x;
}
return par[x] = find(par[x]);
}
void unite(int x, int y)
{
x = find(x);
y = find(y);
if (x == y) return;
if (rank[x] < rank[y]) {
par[x] = y;
size[y] += size[x];
} else {
par[y] = x;
size[x] += size[y];
if (rank[x] == rank[y]) {
rank[x]++;
}
}
gnum--;
}
bool same(int x, int y)
{
return (find(x) == find(y));
}
int getSize(int x)
{
return size[find(x)];
}
int groups()
{
return gnum;
}
};
int main()
{
int s, t, cost;
while (cin >> N >> M, N) {
int res = 0, min_cost = INF;
init();
Union_Find uf(N);
for (int i = 0; i < M; i++) {
cin >> s >> t >> cost;
if (cost > 0) {
G[s].push_back(Edge(s, t, cost));
uf.unite(s, t);
min_cost = min(min_cost, cost);
} else {
res += cost;
}
}
if (uf.gnum == 1) {
if (is_cycle_detect()) {
min_cost = INF;
set<pii> st;
vector<int> v;
for (int i = 0; i < (int)cycle.size(); i++) {
v.push_back(cycle[i].cost);
st.insert(pii(cycle[i].from, cycle[i].to));
}
sort(v.begin(), v.end());
min_cost = v[0] + v[1];
for (int i = 0; i < N; i++) {
for (int j = 0; j < (int)G[i].size(); j++) {
Edge &e = G[i][j];
if (st.count(pii(e.from, e.to)) == 0) {
min_cost = min(min_cost, e.cost);
}
}
}
}
} else {
min_cost = 0;
}
cout << res + min_cost << endl;
}
return 0;
}
|
#include <iostream>
#include <sstream>
#include <string>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cassert>
using namespace std;
#define FOR(i,k,n) for(int i=(k); i<(int)(n); ++i)
#define REP(i,n) FOR(i,0,n)
#define FORIT(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
template<class T> void debug(T begin, T end){ for(T i = begin; i != end; ++i) cerr<<*i<<" "; cerr<<endl; }
inline bool valid(int x, int y, int W, int H){ return (x >= 0 && y >= 0 && x < W && y < H); }
typedef long long ll;
const int INF = 100000000;
const double EPS = 1e-8;
const int MOD = 1000000007;
int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
struct Edge{
int src, dst, cap, rev;
Edge(int u, int v, int c, int r) :
src(u), dst(v), cap(c), rev(r) {}
};
typedef vector<Edge> Node;
typedef vector<Node> Graph;
void add_edge(Graph& G, int a, int b, int c){
G[a].push_back(Edge(a, b, c, G[b].size()));
G[b].push_back(Edge(b, a, c, G[a].size() - 1));
}
int dfs(Graph& G, int u, int t, int f, vector<bool>& used){
if(u == t) return f;
used[u] = true;
FORIT(e, G[u])if(e->cap > 0 && !used[e->dst]){
int g = dfs(G, e->dst, t, min(f, e->cap), used);
if(g > 0) {
e->cap -= g;
G[e->dst][e->rev].cap += g;
return g;
}
}
return 0;
}
int max_flow(Graph G, int s, int t){
int N = G.size();
int flow = 0;
while(true){
vector<bool> used(N, false);
int f = dfs(G, s, t, INF, used);
if(f == 0) return flow;
flow += f;
}
}
int main(){
int N, M;
while(cin >> N >> M && N){
Graph G(N);
int minus = 0;
REP(i, M){
int a, b, c;
cin >> a >> b >> c;
if(c <= 0){
minus += c;
continue;
}
add_edge(G, a, b, c);
}
int ans = INF;
FOR(t, 1, N){
ans = min(ans, max_flow(G, 0, t));
}
cout << ans + minus << endl;
}
return 0;
}
|
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <set>
#include <stack>
#include <queue>
#include <vector>
#include <string>
#include <iostream>
#include <algorithm>
using namespace std;
#define min(a,b) ((a)<(b)?(a):(b))
#define max(a,b) ((a)>(b)?(a):(b))
typedef long long LL;
#define NN 120
#define INF 1LL << 60
LL vis[NN];
LL wet[NN];
LL combine[NN];
LL map[NN][NN];
LL S, T, minCut, N;
void Search(){
LL i, j, Max, tmp;
memset(vis, 0, sizeof(vis));
memset(wet, 0, sizeof(wet));
S = T = -1;
for (i = 0; i < N; i++){
Max = -INF;
for (j = 0; j < N; j++){
if (!combine[j] && !vis[j] && wet[j] > Max){
tmp = j;
Max = wet[j];
}
}
if (T == tmp) return;
S = T; T = tmp;
minCut = Max;
vis[tmp] = 1;
for (j = 0; j < N; j++){
if (!combine[j] && !vis[j]){
wet[j] += map[tmp][j];
}
}
}
}
LL Stoer_Wagner(){
LL i, j;
memset(combine, 0, sizeof(combine));
LL ans = INF;
for (i = 0; i < N - 1; i++){
Search();
if (minCut < ans) ans = minCut;
if (ans == 0) return 0;
combine[T] = 1;
for (j = 0; j < N; j++){
if (!combine[j]){
map[S][j] += map[T][j];
map[j][S] += map[j][T];
}
}
}
return ans;
}
int main(){
LL u, v, m, c;
while( scanf("%lld%lld", &N, &m) && (N+m) ){
memset( map, 0, sizeof( map ) );
LL ans = 0;
for(LL i=0 ; i < m ; ++i){
scanf("%lld%lld%lld", &u, &v, &c);
if( c < 0 ) ans += c;
else if( u != v ){
map[u][v] += c;
map[v][u] += c;
}
}
ans += Stoer_Wagner();
printf("%lld\n", ans);
}
return 0;
}
|
#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <complex>
#include <cmath>
#include <cstdio>
using namespace std;
#define RESIDUE(s,t) (capacity[s][t]-flow[s][t])
#define INF (1ll<<60)
#define REP(i,n) for(int i=0;i<(int)n;++i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()
typedef long long Weight;
struct Edge {
int src, dst;
Weight weight;
Edge(int src, int dst, Weight weight) :
src(src), dst(dst), weight(weight) { }
};
bool operator < (const Edge &e, const Edge &f) {
return e.weight != f.weight ? e.weight > f.weight : // !!INVERSE!!
e.src != f.src ? e.src < f.src : e.dst < f.dst;
}
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
typedef vector<Weight> Array;
typedef vector<Array> Matrix;
Weight minimumCut(const Graph &g) {
int n = g.size();
vector< vector<Weight> > h(n, vector<Weight>(n)); // make adj. matrix
REP(u,n) FOR(e,g[u]) h[e->src][e->dst] += e->weight;
vector<int> V(n); REP(u, n) V[u] = u;
Weight cut = INF;
for(int m = n; m > 1; m--) {
vector<Weight> ws(m, 0);
int u, v;
Weight w;
REP(k, m) {
u = v; v = max_element(ws.begin(), ws.end())-ws.begin();
w = ws[v]; ws[v] = -1;
REP(i, m) if (ws[i] >= 0) ws[i] += h[V[v]][V[i]];
}
REP(i, m) {
h[V[i]][V[u]] += h[V[i]][V[v]];
h[V[u]][V[i]] += h[V[v]][V[i]];
}
V.erase(V.begin()+v);
cut = min(cut, w);
}
return cut;
}
int main(){
int n,m;
while(cin >> n >> m && n){
Graph g(n);
long long ans = 0;
for(int i = 0 ; i < m ; i++){
int a,b,c;
cin >> a >> b >> c;
if( c <= 0 ) ans += c;
else g[a].push_back(Edge(a,b,c)),g[b].push_back(Edge(b,a,c));
}
cout << ans+minimumCut(g) << endl;
}
}
|
#define _USE_MATH_DEFINES
#define INF 100000000
#include <iostream>
#include <sstream>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
#include <map>
#include <string>
#include <cstring>
#include <set>
#include <deque>
#include <bitset>
#include <list>
#include <cstdio>
using namespace std;
typedef long long ll;
typedef pair <int,int> P;
typedef pair <int,P> PP;
static const double EPS = 1e-8;
const int tx[] = {0,1,0,-1};
const int ty[] = {-1,0,1,0};
struct Node {
int to;
int idx;
int flow;
Node(int to,int idx,int flow) :
to(to),idx(idx),flow(flow) {}
};
class FordFulkerson {
private:
vector<Node>* _graph;
bool* _used;
int _size;
int dfs(int src,int flow,int sink){
if(src == sink) return flow;
_used[src] = true;
for(int i= 0;i < _graph[src].size();i++){
Node& e = _graph[src][i];
if(_used[e.to]) continue;
if(e.flow <= 0) continue;
int d = dfs(e.to,min(flow,e.flow),sink);
if(d <= 0) continue;
Node& rev_e = _graph[e.to][e.idx];
e.flow -= d;
rev_e.flow += d;
return d;
}
return 0;
}
public:
FordFulkerson(int n) {
_size = n;
_graph = new vector<Node>[_size];
_used = new bool[_size];
}
~FordFulkerson(){
delete[] _graph;
delete[] _used;
}
FordFulkerson(const FordFulkerson& f){
_size = f.size();
_graph = new vector<Node>[_size];
_used = new bool[_size];
fill((bool*)_used,(bool*)_used + _size,false);
for(int i = 0; i < f.size(); i++){
for(int j = 0; j < f.graph()[i].size(); j++){
_graph[i].push_back(f.graph()[i][j]);
}
}
}
void add_edge(int from,int to,int flow) {
_graph[from].push_back(Node(to,_graph[to].size(),flow));
_graph[to].push_back(Node(from,_graph[from].size()-1,flow));
}
int compute_maxflow(int src,int sink){
int res = 0;
while(true){
fill((bool*)_used,(bool*)_used + _size,false);
int tmp = dfs(src,numeric_limits<int>::max(),sink);
if(tmp == 0) break;
res += tmp;
}
return res;
}
int size() const{
return _size;
}
vector<Node>* graph() const{
return _graph;
}
};
int main(){
int num_of_houses;
int num_of_paths;
while(~scanf("%d %d",&num_of_houses,&num_of_paths)){
if(num_of_houses == 0 && num_of_paths == 0) break;
FordFulkerson ff(num_of_houses);
int bonus = 0;
for(int path_i = 0; path_i < num_of_paths; path_i++){
int from,to;
int cost;
scanf("%d %d %d",&from,&to,&cost);
if(cost < 0) bonus += cost;
ff.add_edge(from,to,max(0,cost));
}
int res = numeric_limits<int>::max();
for(int house_i = 1; house_i< num_of_houses; house_i++){
FordFulkerson tmp(ff);
res = min(res,tmp.compute_maxflow(0,house_i));
}
printf("%d\n",bonus + res);
}
}
|
#include <vector>
#include <numeric>
#include <algorithm>
class unionfind {
private:
int size_;
std::vector<int> parent;
std::vector<int> rank;
public:
unionfind() : size_(0), parent(std::vector<int>()), rank(std::vector<int>()) {};
unionfind(int size__) : size_(size__), parent(std::vector<int>(size_)), rank(std::vector<int>(size_, 0)) {
std::iota(parent.begin(), parent.end(), 0);
}
int size() { return size_; }
int root(int x) {
if (parent[x] == x) return x;
return parent[x] = root(parent[x]);
}
bool same(int x, int y) {
return root(x) == root(y);
}
void unite(int x, int y) {
x = root(x); y = root(y);
if (x == y) return;
if (rank[x] < rank[y]) parent[x] = y;
else if (rank[x] > rank[y]) parent[y] = x;
else parent[y] = x, rank[x]++;
}
};
#include <iostream>
using namespace std;
int n, m, x[109], y[109]; long long c[109]; bool used[109];
bool solve() {
unionfind uf(n);
for (int i = 0; i < m; i++) {
if (used[i]) uf.unite(x[i], y[i]);
}
int s = uf.root(0);
for (int i = 1; i < n; i++) {
if (s != uf.root(i)) return true;
}
return false;
}
int main() {
while (cin >> n >> m, n) {
int sum = 0;
for (int i = 0; i < m; i++) {
cin >> x[i] >> y[i] >> c[i];
if (c[i] > 0) used[i] = true;
else used[i] = false, sum += c[i];
}
long long ret = 1LL << 60;
if (solve()) ret = sum;
for (int i = 0; i < m; i++) {
if (!used[i]) continue;
used[i] = false;
if (solve()) ret = min(ret, sum + c[i]);
used[i] = true;
}
for (int i = 0; i < m; i++) {
if (!used[i]) continue;
used[i] = false;
for (int j = i + 1; j < m; j++) {
if (!used[j]) continue;
used[j] = false;
if (solve()) ret = min(ret, sum + c[i] + c[j]);
used[j] = true;
}
used[i] = true;
}
cout << ret << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define pb push_back
#define pf push_front
#define mp make_pair
#define fr first
#define sc second
#define Rep(i, n) for ( int i = 0 ; i < (n); i++ )
#define All(v) v.begin(), v.end()
typedef pair<int, int> Pii; typedef pair<int, Pii> Pip;
const int INF = 1107110711071107;
vector<Pii> G[101];
int min_bridge = INF;
int ord[101], low[101];
bool vis[101];
void dfs(int v, int p, int &k) {
vis[v] = true;
ord[v] = k++;
low[v] = ord[v];
Rep(i, G[v].size()) {
if ( !vis[G[v][i].fr] ) {
dfs(G[v][i].fr, v, k);
low[v] = min(low[v], low[G[v][i].fr]);
if ( ord[v] < low[G[v][i].fr] ) min_bridge = min(min_bridge, G[v][i].sc);
} else if ( G[v][i].fr != p ) {
low[v] = min(low[v], ord[G[v][i].fr]);
}
}
}
void dfs2(int v) {
if ( vis[v] ) return;
vis[v] = true;
Rep(i, G[v].size()) {
dfs2(G[v][i].fr);
}
}
signed main() {
int n, m;
while ( cin >> n >> m, n | m ) {
int minus_cost = 0;
min_bridge = INF;
int min_1 = INF, min_2 = INF;
Rep(i, 101) {
G[i].clear();
vis[i] = false;
}
Rep(i, m) {
int a, b, c;
cin >> a >> b >> c;
if ( c <= 0 ) minus_cost += c;
else {
if ( min_1 > c ) min_2 = min_1, min_1 = c;
else if ( min_2 > c ) min_2 = c;
G[a].pb(Pii(b, c));
G[b].pb(Pii(a, c));
}
}
dfs2(0);
bool is_connected = true;
Rep(i, n) {
if ( !vis[i] ) {
is_connected = false;
break;
}
}
if ( !is_connected ) {
cout << minus_cost << endl;
continue;
}
Rep(i, n) vis[i] = false;
int k = 0;
Rep(i, n) {
if ( !vis[i] ) dfs(i, -1, k);
}
if ( min_bridge == INF ) cout << minus_cost << endl;
else cout << min(min_bridge, min_1+min_2) + minus_cost << endl;
}
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
#include <map>
#include <string>
#include <queue>
using namespace std;
#define SZ(v) ((int)(v).size())
const int maxint = -1u>>1;
const int maxn = 100 + 30;
typedef long long ll;
int n, m;
ll adj[maxn][maxn];
int f[maxn], bestf[maxn];
int find(int v) {
if (v != bestf[v]) {
return bestf[v] = find(bestf[v]);
}
return v;
}
int bestff;
int v[maxn];
ll w[maxn];
bool a[maxn];
vector<pair<int, int> > res;
ll mincut() {
ll ans = (-1ull) >> 1;
//for (int i = 0; i < n; ++i) {
//for (int j = 0; j < n; ++j) {
//adj[i][j] = -adj[i][j];
//}
//}
for (int i = 0; i < n; ++i) {
f[i] = v[i] = i;
}
for (int t = n; t > 1; --t) {
a[0] = true;
for (int i = 1; i < t; ++i) {
a[i] =false;
w[i] = adj[v[0]][v[i]];
}
int prev = v[0];
for (int i = 1; i < t; ++i) {
int zj = -1;
for (int j = 1; j < t; ++j) {
if (a[j] == false && (zj == -1 || w[j] > w[zj])) {
zj = j;
}
}
a[zj] = true;
if (i == t - 1) {
if (w[zj] < ans) {
ans = w[zj];
copy(f, f + n, bestf);
bestff = v[zj];
}
for (int k = 0; k < t; ++k) {
adj[v[k]][prev] = adj[prev][v[k]] += adj[v[zj]][v[k]];
}
f[v[zj]] = prev;
v[zj] = v[t - 1];
break;
}
prev = v[zj];
for (int j = 1; j < t; ++j) {
if (a[j] == false) {
w[j] += adj[v[zj]][v[j]];
}
}
}
}
//bool flag[maxn] = {};
//for (int i = 0; i < n; ++i) {
//if (find(i) == bestff) {
//flag[i] = true;
//}
//}
//res.clear();
//for (int i = 0; i < n; ++i) {
//for (int j = i + 1; j < n; ++j) {
//if (flag[i] == flag[j] && save[i][j]) {
//res.push_back(make_pair(i, j));
//}
//}
//}
return ans;
}
void gao() {
ll ans = 0;
memset(adj, 0, sizeof(adj));
for (int i = 0, a, b; i < m; ++i) {
ll c;
scanf ("%d%d%lld", &a, &b, &c);
if (c < 0) {
ans += c;
} else {
adj[a][b] = adj[b][a] = adj[a][b] + c;
}
}
printf("%lld\n", ans + mincut());
}
int main() {
while (scanf("%d%d", &n, &m) == 2 && (n || m)) {
gao();
}
return 0;
}
|
#include<iostream>
#include<vector>
#include<cassert>
#include<queue>
using namespace std;
#define rep(i, n) for (int i = 0 ; i < int(n); ++i)
int main() {
while (true) {
long long n, m;
cin >> n >> m;
if (n == 0 && m == 0) break;
assert(n >= m);
long long sum = 0, mn = 1234567890123456789LL, mn1 = 1234567890321456789LL;
vector<pair<long long, pair<int, long long> > > edge[n];
rep (i, m) {
long long x, y, c;
cin >> x >> y >> c;
if (c <= 0) sum += c;
else {
if (c <= mn) {
mn1 = mn;
mn = c;
} else if (c < mn1) {
mn1 = c;
}
edge[x].push_back(make_pair(y, make_pair(i, c)));
edge[y].push_back(make_pair(x, make_pair(i, c)));
}
}
long long res = mn + mn1;
{
bool can[111][111] = {};
rep (i, n) {
queue<long long> pos;
pos.push(i);
while (!pos.empty()) {
long long now = pos.front();
pos.pop();
if (can[i][now]) continue;
can[i][now] = true;
rep (j, edge[now].size()) {
pos.push(edge[now][j].first);
}
}
}
rep (i, n) rep (j, n) if (!can[i][j] && !can[j][i]) {
cout << sum << endl;
goto next;
}
}
rep (iii, n) rep (jjj, edge[iii].size()) {
bool can[111][111] = {};
int num = edge[iii][jjj].second.first;
rep (i, n) {
queue<long long> pos;
pos.push(i);
while (!pos.empty()) {
long long now = pos.front();
pos.pop();
if (can[i][now]) continue;
can[i][now] = true;
rep (j, edge[now].size()) {
if (edge[now][j].second.first == num) continue;
pos.push(edge[now][j].first);
}
}
}
rep (i, n) rep (j, n) if (!can[i][j] && !can[j][i]) {
res = min(res, edge[iii][jjj].second.second);
}
}
cout << sum + res << endl;
next:;
}
return 0;
}
|
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cfloat>
#include <map>
#include <set>
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <cstdio>
#include <cstring>
#include <iterator>
#include <bitset>
#include <unordered_set>
#include <unordered_map>
#include <fstream>
#include <iomanip>
//#include <utility>
//#include <memory>
//#include <functional>
//#include <deque>
//#include <cctype>
//#include <ctime>
//#include <numeric>
//#include <list>
//#include <iomanip>
//#if __cplusplus >= 201103L
//#include <array>
//#include <tuple>
//#include <initializer_list>
//#include <forward_list>
//
//#define cauto const auto&
//#else
//#endif
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef vector<int> vint;
typedef vector<vector<int> > vvint;
typedef vector<long long> vll, vLL;
typedef vector<vector<long long> > vvll, vvLL;
#define VV(T) vector<vector< T > >
template <class T>
void initvv(vector<vector<T> > &v, int a, int b, const T &t = T()){
v.assign(a, vector<T>(b, t));
}
template <class F, class T>
void convert(const F &f, T &t){
stringstream ss;
ss << f;
ss >> t;
}
#undef _P
#define _P(...) (void)printf(__VA_ARGS__)
#define reep(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) reep((i),0,(n))
#define ALL(v) (v).begin(),(v).end()
#define PB push_back
#define F first
#define S second
#define mkp make_pair
#define RALL(v) (v).rbegin(),(v).rend()
#define DEBUG
#ifdef DEBUG
#define dump(x) cout << #x << " = " << (x) << endl;
#define debug(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
#else
#define dump(x)
#define debug(x)
#endif
#define LDcout(x,n) fixed<<setprecision(n)<<x
#define MOD 1000000007LL
#define EPS 1e-8
static const int INF=1<<24;
//max flow (dinic)
template<class V> class MaxFlow_dinic{
public:
struct edge{int to,reve;V cap;};
static const int MV = 1100;
vector<edge> E[MV];
int itr[MV],lev[MV];
void add_edge(int x,int y,V cap,bool undir=false){
E[x].push_back((edge){y,(int)E[y].size(),cap});
E[y].push_back((edge){x,(int)E[x].size()-1,undir?cap:0});
}
void bfs(int cur){
memset(lev,0xff,sizeof(lev));
queue<int> q;
lev[cur]=0;
q.push(cur);
while(q.size()){
int v=q.front();
q.pop();
for(__typeof(E[v].begin()) e=E[v].begin();e!=E[v].end();e++) if(e->cap>0&&lev[e->to]<0) lev[e->to]=lev[v]+1,q.push(e->to);
}
}
V dfs(int from,int to,V cf){
if(from==to){
return cf;
}
for(;itr[from]<E[from].size();itr[from]++){
edge* e=&E[from][itr[from]];
if(e->cap>0&&lev[from]<lev[e->to]){
V f=dfs(e->to,to,min(cf,e->cap));
if(f>0){
e->cap-=f;
E[e->to][e->reve].cap += f;
return f;
}
}
}
return 0;
}
V maxflow(int from,int to){
V fl=0,tf;
while(1){
bfs(from);
if(lev[to]<0) return fl;
memset(itr,0,sizeof(itr));
while((tf=dfs(from,to,numeric_limits<V>::max()))>0) fl+=tf;
}
}
};
void mainmain(){
int n,m;
while(cin>>n>>m,n||m){
ll ans=INT_MAX;
vint a(m),b(m),c(m);
rep(i,m) cin>>a[i]>>b[i]>>c[i];
reep(i,1,n){
MaxFlow_dinic<ll> mf;
int tmp=0;
rep(j,m){
if(c[j]<0) tmp+=c[j];
else mf.add_edge(a[j],b[j],(ll)c[j],true);
}
ans=min(ans,tmp+mf.maxflow(0,i));
}
cout<<ans<<endl;
}
}
signed main() {
ios_base::sync_with_stdio(false);
cout<<fixed<<setprecision(0);
mainmain();
}
|
#include <iostream>
#include <cstdio>
#include <cassert>
#include <cstring>
#include <vector>
#include <valarray>
#include <array>
#include <queue>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <algorithm>
#include <cmath>
#include <complex>
#include <random>
using namespace std;
using ll = long long;
using ull = unsigned long long;
constexpr ll TEN(int n) {return (n==0)?1:10*TEN(n-1);}
int bsr(int x) { return 31 - __builtin_clz(x); }
template <class E>
using Graph = vector<vector<E>>;
// NOT VERIFY
template<class D, D INF>
struct BidirectedCut {
D sum = INF;
template<class E>
BidirectedCut(Graph<E> g) {
int n = (int)g.size();
int m_a = -1, m_b = -1;
vector<D> dist_base(n, 0);
for (int m = n; m > 1; m--) {
int a, b;
auto dist = dist_base;
for (int i = 0; i < m; i++) {
a = b; b = max_element(begin(dist), end(dist)) - begin(dist);
if (i == m-1) sum = min(sum, dist[b]);
dist[b] = -INF;
for (E &e: g[b]) {
if (e.to == m_b) e.to = m_a;
if (dist[e.to] == -INF) continue;
dist[e.to] += e.dist;
}
}
//merge a, b
m_a = a; m_b = b;
g[a].insert(end(g[a]), begin(g[b]), end(g[b]));
g[b].clear();
dist_base[b] = -INF;
}
}
};
/**
* Dinic?????????????????§???
*
* ?????¨???????????¬????????????
* template?????°???int V???????????°
* Edge??????rev?????????
* ---
* void add_edge(Graph<Edge> &g, int from, int to, int cap) {
* g[from].push_back(Edge{to, cap, (int)g[to].size()});
* g[to].push_back(Edge{from, 0, (int)g[from].size()-1});
* }
* ---
*/
template<class C, C INF> // Cap
struct MaxFlow {
int V;
vector<int> level, iter;
//g?????´?£????????????§??¨???
template<class E>
C exec(Graph<E> &g, int s, int t) {
V = (int)g.size();
level.resize(V);
iter.resize(V);
C flow = 0;
while (true) {
bfs(g, s);
if (level[t] < 0) return flow;
fill_n(iter.begin(), V, 0);
while (true) {
C f = dfs(g, s, t, INF);
if (!f) break;
flow += f;
}
}
}
template<class E>
void bfs(const Graph<E> &g, int s) {
fill_n(level.begin(), V, -1);
queue<int> que;
level[s] = 0;
que.push(s);
while (!que.empty()) {
int v = que.front(); que.pop();
for (E e: g[v]) {
if (e.cap <= 0) continue;
if (level[e.to] < 0) {
level[e.to] = level[v] + 1;
que.push(e.to);
}
}
}
}
template<class E>
C dfs(Graph<E> &g, int v, int t, C f) {
if (v == t) return f;
C res = 0;
for (int &i = iter[v]; i < (int)g[v].size(); i++) {
E &e = g[v][i];
if (e.cap <= 0) continue;
if (level[v] < level[e.to]) {
C d = dfs(g, e.to, t, min(f, e.cap));
if (d <= 0) continue;
e.cap -= d;
g[e.to][e.rev].cap += d;
return d;
}
}
return res;
}
};
int rand_int(int l, int r) { //[l, r)
using D = uniform_int_distribution<int>;
static random_device rd;
static mt19937 gen(rd());
return D(l, r-1)(gen);
}
bool solve() {
int n, m;
cin >> n >> m;
if (!n) return false;
struct Edge {
int to;
ll dist;
};
Graph<Edge> g(n);
auto addEdge = [&](int a, int b, ll c) {
g[a].push_back(Edge{b, c});
g[b].push_back(Edge{a, c});
};
ll s = 0;
for (int i = 0; i < m; i++) {
int a, b; ll c;
cin >> a >> b >> c;
if (c < 0) {
s += c;
continue;
}
addEdge(a, b, c);
}
cout << s+BidirectedCut<ll, TEN(15)>(g).sum << endl;
return true;
}
int main() {
while (solve()) {}
return 0;
}
|
#include<iostream>
#include<cmath>
#include<cstdio>
#include<vector>
#include<algorithm>
#include<cassert>
#include<climits>
#include<map>
#include<set>
#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
#define IINF (INT_MAX)
#define MAX 200
using namespace std;
struct Data{
int from,to,cost,index;
Data(int from=-1,int to=-1,int cost=-1,int index=-1):from(from),to(to),cost(cost),index(index){}
};
int V,E;
vector<Data> G[MAX];
bool visited[MAX];
void isconnect(int cur,int &counter,int *ban){
if(visited[cur])return;
visited[cur] = true;
counter++;
rep(i,G[cur].size()){
if( ban[0] == G[cur][i].index || ban[1] == G[cur][i].index ) continue;
isconnect(G[cur][i].to,counter,ban);
}
}
int main(){
while(cin >> V >> E,V|E){
Data *input = new Data[E];
int mincost = IINF,coef = 0;
rep(i,V)G[i].clear();
rep(i,E){
cin >> input[i].from >> input[i].to >> input[i].cost;
input[i].index = i;
if( input[i].cost < 0 ) coef += input[i].cost;
else {
G[input[i].from].push_back(input[i]);
G[input[i].to].push_back(Data(input[i].to,input[i].from,input[i].cost,input[i].index));
}
}
int counter = 0;
int ban[2] = {-1,-1};
rep(i,V)visited[i] = false;
isconnect(0,counter,ban);
if(counter != V)mincost = min(mincost,coef);
rep(i,E){
if( input[i].cost < 0 ) continue;
rep(j,E){
if( input[j].cost < 0 ) continue;
rep(k,V)visited[k] = false;
ban[0] = i, ban[1] = j;
counter = 0;
isconnect(0,counter,ban);
if( counter != V )mincost = min(mincost,coef+input[i].cost+((i==j)?0:input[j].cost));
}
}
cout << mincost << endl;
delete [] input;
}
return 0;
}
|
#include <iostream>
#include <string>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <ctime>
#include <queue>
#include <stack>
#include <list>
#include <algorithm>
using namespace std;
#define typec long long
#define V 111
typec g[V][V], w[V];
typec a[V], v[V], na[V];
typec Stoer_Wagner(int n)
{
typec i, j, pv, zj,I=1;
typec best = I<<32;
for (i = 0; i < n; i++) v[i] = i; // vertex: 0 ~ n-1
while (n > 1)
{
for (a[v[0]] = 1, i = 1; i < n; i++)
{
a[v[i]] = 0;
na[i - 1] = i;
w[i] = g[v[0]][v[i]];
}
for (pv = v[0], i = 1; i < n; i++ )
{
for (zj = -1, j = 1; j < n; j++ )
if (!a[v[j]] && (zj < 0 || w[j] > w[zj]))
zj = j;
a[v[zj]] = 1;
if (i == n - 1)
{
if (best > w[zj]) best = w[zj];
for (i = 0; i < n; i++)
g[v[i]][pv] = g[pv][v[i]] += g[v[zj]][v[i]];
v[zj] = v[--n];
break;
}
pv = v[zj];
for (j = 1; j < n; j++)
if(!a[v[j]])
w[j] += g[v[zj]][v[j]];
}
}
return best;
}
bool vis[111];
void dfs(int u,int n)
{
for(int v=0;v<n;++v)
if(g[u][v]!=0&&vis[v]==0)
{
vis[v]=1;
dfs(v,n);
}
}
bool ok(int n)
{
for(int i=0;i<n;++i)
if(vis[i]==0)return 1;
return 0;
}
int main()
{
//freopen("G:\\in.txt","r",stdin);
int n, m, u, v, w;
while(scanf("%d%d", &n, &m),n+m)
{
memset(g, 0, sizeof(g));
typec ans=0;
while(m --)
{
scanf("%d%d%d", &u, &v, &w);
if(w<=0)ans+=w;
else g[v][u]= g[u][v] = w;
}
// memset(vis,0,sizeof(vis));
//dfs(0,n);
//if(ok(n))puts("0");
printf("%lld\n", ans+Stoer_Wagner(n));
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
using Int = long long;
struct SCC{
int n;
vector<vector<int> > G,rG,T,C;
vector<int> vs,used,belong;
SCC(){};
SCC(int sz):n(sz),G(sz),rG(sz),used(sz),belong(sz){}
void add_edge(int from,int to){
G[from].push_back(to);
rG[to].push_back(from);
}
void dfs(int v){
used[v] = 1;
for(int i=0;i<(int)G[v].size();i++){
if(!used[G[v][i]]) dfs(G[v][i]);
}
vs.push_back(v);
}
void rdfs(int v,int k){
used[v] = 1;
belong[v] = k;
C[k].push_back(v);
for(int i=0;i<(int)rG[v].size();i++) {
if(!used[rG[v][i]]) rdfs(rG[v][i],k);
}
}
int build(){
fill(used.begin(),used.end(),0);
vs.clear();
for(int v=0;v<n;v++){
if(!used[v]) dfs(v);
}
fill(used.begin(),used.end(),0);
int k=0;
for(int i=vs.size()-1;i>=0;i--){
if(!used[vs[i]]){
T.push_back(vector<int>());
C.push_back(vector<int>());
rdfs(vs[i],k++);
}
}
return k;
}
};
struct UnionFind{
int n;
vector<int> r,p;
UnionFind(int n):n(n),r(n,1),p(n){iota(p.begin(),p.end(),0);}
int find(int x){
if(x==p[x]) return x;
return p[x]=find(p[x]);
}
void unite(int x,int y){
x=find(x);y=find(y);
if(x==y) return;
if(r[x]<r[y]) swap(x,y);
r[x]+=r[y];
p[y]=x;
}
};
signed main(){
cin.tie(0);
ios::sync_with_stdio(0);
int n,m;
while(cin>>n>>m,n){
vector<int> x(m),y(m),c(m);
int ans=0;
UnionFind uf(n);
SCC scc(n);
for(int i=0;i<m;i++){
cin>>x[i]>>y[i]>>c[i];
if(c[i]<=0) ans+=c[i];
else{
scc.add_edge(x[i],y[i]);
uf.unite(x[i],y[i]);
}
}
if(uf.r[uf.find(0)]!=n){
cout<<ans<<endl;
continue;
}
scc.build();
//cout<<ans<<endl;
auto b=scc.belong;
vector<int> v;
int t=-1;
for(int i=0;i<m;i++){
if(c[i]<=0) continue;
if(b[x[i]]==b[y[i]]){
v.emplace_back(c[i]);
continue;
}
if(t<0||c[i]<t) t=c[i];
}
sort(v.begin(),v.end());
if(!v.empty()&&(t<0||v[0]+v[1]<t)) t=v[0]+v[1];
cout<<ans+t<<endl;
}
return 0;
}
|
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <cfloat>
#include <ctime>
#include <cassert>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <numeric>
#include <list>
#include <iomanip>
using namespace std;
#ifdef _MSC_VER
#define __typeof__ decltype
template <class T> int popcount(T n) { return n ? 1 + popcount(n & (n - 1)) : 0; }
#endif
#ifdef __GNUC__
template <class T> int popcount(T n);
template <> int popcount(unsigned int n) { return n ? __builtin_popcount(n) : 0; }
template <> int popcount(int n) { return n ? __builtin_popcount(n) : 0; }
template <> int popcount(unsigned long long n) { return n ? __builtin_popcountll(n) : 0; }
template <> int popcount(long long n) { return n ? __builtin_popcountll(n) : 0; }
#endif
#define foreach(it, c) for (__typeof__((c).begin()) it=(c).begin(); it != (c).end(); ++it)
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define CL(arr, val) memset(arr, val, sizeof(arr))
#define rep(i, n) for (int i = 0; i < n; ++i)
template <class T> void max_swap(T& a, const T& b) { a = max(a, b); }
template <class T> void min_swap(T& a, const T& b) { a = min(a, b); }
typedef long long ll;
typedef pair<int, int> pint;
const double EPS = 1e-8;
const double PI = acos(-1.0);
const int dx[] = { 0, 1, 0, -1 };
const int dy[] = { 1, 0, -1, 0 };
bool valid_pos(int x, int y, int w, int h) { return 0 <= x && x < w && 0 <= y && y < h; }
template <class T> void print(T a, int n, int br = 1, const string& deli = ", ") { cout << "{ "; for (int i = 0; i < n; ++i) { cout << a[i]; if (i + 1 != n) cout << deli; } cout << " }"; while (br--) cout << endl; }
template <class T> void print(const vector<T>& v, int br = 1, const string& deli = ", ") { print(v, v.size(), br, deli); }
template <class T>
class UnionFind
{
private:
T* parent;
T* rank;
public:
int groups;
UnionFind(int n)
: groups(n)
{
parent = new T[n];
rank = new T[n];
for (int i = 0; i < n; ++i)
{
parent[i] = i;
rank[i] = 0;
}
}
void unite(T a, T b)
{
T root_a = find(a);
T root_b = find(b);
if (root_a == root_b)
return;
--groups;
if (rank[root_a] < rank[root_b])
parent[root_a] = root_b;
else if (rank[root_a] > rank[root_b])
parent[root_b] = root_a;
else
{
parent[root_a] = root_b;
++rank[root_a];
}
}
bool same(T a, T b)
{
return find(a) == find(b);
}
T find(T e)
{
if (parent[e] == e)
return e;
else
return parent[e] = find(parent[e]);
}
};
class SCC
{
public:
int V;
vector<vector<int> > g;
vector<vector<int> > rg;
vector<int> vs; // 帰りの順番, 後ろのほう要素は始点側
vector<bool> used;
vector<int> component;
SCC(int V)
: V(V), g(V), rg(V), vs(V), used(V), component(V) { }
void add_edge(int from, int to)
{
g[from].push_back(to);
rg[to].push_back(from);
}
void dfs(int v)
{
used[v] = true;
for (int i = 0; i < g[v].size(); ++i)
if (!used[g[v][i]])
dfs(g[v][i]);
vs.push_back(v);
}
void rdfs(int v, int k)
{
used[v] = true;
component[v] = k;
for (int i = 0; i < rg[v].size(); ++i)
if (!used[rg[v][i]])
rdfs(rg[v][i], k);
}
// 強連結成分の数を返す
// O(V + E)
// グラフの始点側の値(component[v])は小さい
// 末端は大きい値, 最末端(component[v] == scc() - 1)
int scc()
{
vs.clear();
fill(used.begin(), used.end(), false);
for (int i = 0; i < V; ++i)
if (!used[i])
dfs(i);
fill(used.begin(), used.end(), false);
int k = 0;
for (int i = vs.size() - 1; i >= 0; --i)
if (!used[vs[i]])
rdfs(vs[i], k++);
return k;
}
};
int main()
{
ios::sync_with_stdio(false);
int n, m;
while (cin >> n >> m, n)
{
vector<pint> e[128]; // (to, cost)
UnionFind<int> uf(n);
int res = 0;
while (m--)
{
int x, y, c;
cin >> x >> y >> c;
if (c <= 0)
res += c;
else
{
e[x].push_back(pint(y, c));
uf.unite(x, y);
}
}
if (uf.groups == 1)
{
SCC scc(n);
for (int i = 0; i < n; ++i)
for (int j = 0; j < e[i].size(); ++j)
scc.add_edge(i, e[i][j].first);
scc.scc();
int min_cost = INT_MAX;
map<int, vector<int> > cost_in_scc;
for (int i = 0; i < n; ++i)
{
for (int j = 0; j < e[i].size(); ++j)
{
int x = i, y = e[i][j].first, c = e[i][j].second;
if (scc.component[x] != scc.component[y])
min_swap(min_cost, c);
else
cost_in_scc[scc.component[x]].push_back(c);
}
}
foreach (it, cost_in_scc)
{
vector<int>& v = it->second;
sort(all(v));
min_swap(min_cost, v[0] + v[1]);
}
res += min_cost;
}
cout << res << endl;
}
}
|
#include<stdio.h>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
const int D_MAX_V=210;
const int D_v_size=210;
struct D_wolf{
int t,r;
long long c;
D_wolf(){t=c=r=0;}
D_wolf(int t1,long long c1,int r1){
t=t1;c=c1;r=r1;
}
};
vector<D_wolf>D_G[D_MAX_V];
int D_level[D_MAX_V];
int D_iter[D_MAX_V];
void add_edge(int from,int to,long long cap){
D_G[from].push_back(D_wolf(to,cap,D_G[to].size()));
D_G[to].push_back(D_wolf(from,0,D_G[from].size()-1));
}
void D_bfs(int s){
for(int i=0;i<D_v_size;i++)D_level[i]=-1;
queue<int> Q;
D_level[s]=0;
Q.push(s);
while(Q.size()){
int v=Q.front();
Q.pop();
for(int i=0;i<D_G[v].size();i++){
if(D_G[v][i].c>0&&D_level[D_G[v][i].t]<0){
D_level[D_G[v][i].t]=D_level[v]+1;
Q.push(D_G[v][i].t);
}
}
}
}
long long D_dfs(int v,int t,long long f){
if(v==t)return f;
for(;D_iter[v]<D_G[v].size();D_iter[v]++){
int i=D_iter[v];
if(D_G[v][i].c>0&&D_level[v]<D_level[D_G[v][i].t]){
long long d=D_dfs(D_G[v][i].t,t,min(f,D_G[v][i].c));
if(d>0){
D_G[v][i].c-=d;
D_G[D_G[v][i].t][D_G[v][i].r].c+=d;
return d;
}
}
}
return 0;
}
long long max_flow(int s,int t){
long long flow=0;
for(;;){
D_bfs(s);
if(D_level[t]<0)return flow;
for(int i=0;i<D_v_size;i++)D_iter[i]=0;
long long f;
while((f=D_dfs(s,t,9999999999999LL))>0){flow+=f;}
}
return 0;
}
long long INF=9999999999999LL;
int p[30000];
int q[30000];
int r[30000];
int main(){
int a,b;
while(scanf("%d%d",&a,&b),a){
for(int i=0;i<b;i++){
scanf("%d%d%d",p+i,q+i,r+i);
}
long long ret=999999999999999LL;
for(int i=1;i<a;i++){
for(int j=0;j<D_MAX_V;j++){
D_G[j].clear();
D_iter[j]=D_level[j]=0;
}
long long tmp=0;
/* for(int j=0;j<a;j++){
add_edge(j,j+a,INF);
if(j==0)add_edge(s,j,INF);
else add_edge(s,j,0);
if(j==i)add_edge(j+a,t,INF);
else add_edge(j+a,t,0);
}*/
for(int j=0;j<b;j++){
if(r[j]<=0){
tmp+=r[j];continue;
}
add_edge(p[j],q[j],r[j]);
add_edge(q[j],p[j],r[j]);
}
ret=min(ret,tmp+max_flow(0,i));
}
printf("%lld\n",ret);
}
}
|
#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
const int inf = 0x3f3f3f3f ;
const int maxw = 1000 ;
int g[105][105] , w[105] ;
int a[105] , v[105] , na[105] ;
int n , m ;
int mincut( int n ) {
int i , j, pv , zj ;
int best = inf ;
for( i = 0 ; i < n; i ++ ) {
v[i] = i ;
}
while( n > 1 ) {
for( a[v[0]] = 1 , i = 1 ; i < n; i ++ ) {
a[v[i]] = 0 ; na[i-1] = i ;
w[i] = g[v[0]][v[i]] ;
}
for( pv = v[0] ,i = 1 ; i < n ; i ++ ) {
for( zj = -1 , j = 1 ; j < n ; j ++ )
if( !a[v[j]] && (zj<0||w[j]>w[zj]))
zj = j ;
a[v[zj]] = 1 ;
if( i == n - 1 ) {
if( best > w[zj] ) best = w[zj] ;
for( i = 0 ; i < n; i++ ) {
g[v[i]][pv] = g[pv][v[i]] +=g[v[zj]][v[i]] ;
}
v[zj] = v[--n] ;
break;
}
pv = v[zj] ;
for( j = 1 ; j < n; j ++ ) if( !a[v[j]])
w[j] += g[v[zj]][v[j]] ;
}
}
return best ;
}
int main(){
while( scanf( "%d%d" , &n , &m ) != EOF ) {
if( n == 0 && m == 0 ) break;
memset( g , 0 , sizeof(g) ) ;
int ans = 0 ;
int i ;
for( i = 1 ; i <= m ;i ++ ) {
int from , to ,val ;
scanf( "%d%d%d" , &from , &to , &val ) ;
if( val < 0 ) {
ans += val ;
continue ;
}
if( g[from][to] == inf ) {
g[from][to] = val ;
}else{
g[from][to] += val ;
}
g[to][from] = g[from][to] ;
}
printf( "%d\n" , ans + mincut(n) ) ;
}
return 0 ;
}
|
#include<stdio.h>
#include<algorithm>
#include<vector>
struct S{int f,t,c;}s;
int C(S l,S r){return l.c>r.c;}
int u[100],r[100];
int F(int x)
{
return (u[x]-x?u[x]=F(u[x]):x);
}
void U(int x,int y)
{
x=F(x),y=F(y);
if(r[x]>r[y])u[y]=x;
else if(r[x]<r[y])u[x]=y;
else u[x]=y,++r[y];
}
int main()
{
int n,m,i,a;
while(scanf("%d%d",&n,&m),n)
{
std::vector<S>v;
for(a=i=0;i<n;++i)r[u[i]=i]=1;
while(m--)
{
scanf("%d%d%d",&s.f,&s.t,&s.c);
if(s.c>0)v.push_back(s);
else a+=s.c;
}
std::sort(v.begin(),v.end(),C);
for(i=0;i<v.size();++i)
{
s=v[i];
if(F(s.f)!=F(s.t))
{
if(n>2)U(s.f,s.t),--n;
else a+=s.c;
}
}
printf("%d\n",a);
}
return 0;
}
|
#include<queue>
#include<cstdio>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
const int INF=1<<29;
template<class T>
struct AdjMatrix:public vector< vector<T> >{
AdjMatrix(int n,const vector<T> &v=vector<T>()):vector< vector<T> >(n,v){}
};
template<class T>
T augment(const AdjMatrix<T> &capa,int src,int snk,AdjMatrix<T> &flow){
int n=capa.size();
vector<int> parent(n,-1); parent[src]=-2;
T water=0;
queue< pair<T,int> > qu; qu.push(make_pair(INF,src));
while(!qu.empty()){
pair<T,int> a=qu.front(); qu.pop();
int u=a.second;
T w=a.first;
if(u==snk){ water=w; break; }
rep(v,n) if(parent[v]==-1 && capa[u][v]-flow[u][v]>0) {
qu.push(make_pair(min(w,capa[u][v]-flow[u][v]),v));
parent[v]=u;
}
}
if(water==0) return 0;
for(int v=snk,u=parent[snk];v!=src;v=u,u=parent[u]){
flow[u][v]+=water;
flow[v][u]-=water;
}
return water;
}
template<class T>
T FordFulkerson(const AdjMatrix<T> &capa,int src,int snk){
int n=capa.size();
AdjMatrix<T> flow(n,vector<T>(n));
T ans=0;
while(1){
T water=augment(capa,src,snk,flow);
if(water==0) break;
ans+=water;
}
return ans;
}
int main(){
for(int n,m;scanf("%d%d",&n,&m),n;){
int ans=0;
AdjMatrix<int> adj(n,vector<int>(n));
rep(i,m){
int u,v,w; scanf("%d%d%d",&u,&v,&w);
if(w<0) ans+=w;
adj[u][v]=adj[v][u]=max(w,0);
}
int ans2=INF;
rep(v,n) if(v!=0) ans2=min(ans2,FordFulkerson(adj,0,v));
printf("%d\n",ans+ans2);
}
return 0;
}
|
#define _USE_MATH_DEFINES
#define INF 100000000
#include <iostream>
#include <sstream>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
#include <map>
#include <string>
#include <cstring>
#include <set>
#include <deque>
#include <bitset>
#include <list>
#include <cstdio>
using namespace std;
typedef long long ll;
typedef pair <int,int> P;
typedef pair <int,P> PP;
static const double EPS = 1e-8;
const int tx[] = {0,1,0,-1};
const int ty[] = {-1,0,1,0};
struct Node {
int to;
int idx;
int flow;
Node(int to,int idx,int flow) :
to(to),idx(idx),flow(flow) {}
};
class FordFulkerson {
private:
vector<Node>* _graph;
bool* _used;
int _size;
int dfs(int src,int flow,int sink){
if(src == sink) return flow;
_used[src] = true;
for(int i= 0;i < _graph[src].size();i++){
Node& e = _graph[src][i];
if(_used[e.to]) continue;
if(e.flow <= 0) continue;
int next_flow = min(flow,e.flow);
int d = dfs(e.to,next_flow,sink);
if(d <= 0) continue;
Node& rev_e = _graph[e.to][e.idx];
e.flow -= d;
rev_e.flow += d;
return d;
}
return 0;
}
public:
FordFulkerson(int n) {
_size = n;
_graph = new vector<Node>[_size];
_used = new bool[_size];
}
FordFulkerson(const FordFulkerson& f){
_size = f.size();
_graph = new vector<Node>[_size];
_used = new bool[_size];
fill((bool*)_used,(bool*)_used + _size,false);
for(int i = 0; i < f.size(); i++){
for(int j = 0; j < f.graph()[i].size(); j++){
_graph[i].push_back(f.graph()[i][j]);
}
}
}
void add_edge(int from,int to,int flow) {
_graph[from].push_back(Node(to,_graph[to].size(),flow));
_graph[to].push_back(Node(from,_graph[from].size()-1,flow));
}
int compute_maxflow(int src,int sink){
int res = 0;
while(true){
fill((bool*)_used,(bool*)_used + _size,false);
int tmp = dfs(src,numeric_limits<int>::max(),sink);
if(tmp == 0) break;
res += tmp;
}
return res;
}
int size() const{
return _size;
}
vector<Node>* graph() const{
return _graph;
}
};
class UnionFindTree {
private:
int* par;
int* rank;
public:
UnionFindTree(int n){
par = new int[n]();
rank = new int[n]();
for(int i=0;i<n;i++){
par[i] = i;
rank[i] = 0;
}
}
~UnionFindTree(){
delete[] rank;
delete[] par;
}
int find(int x){
if(par[x] == x){
return x;
} else {
return par[x] = find(par[x]);
}
}
void unite(int x,int y){
x = find(x);
y = find(y);
if (x == y) return;
par[x] = y;
}
bool same(int x,int y){
return find(x) == find(y);
}
};
int main(){
int num_of_houses;
int num_of_paths;
while(~scanf("%d %d",&num_of_houses,&num_of_paths)){
if(num_of_houses == 0 && num_of_paths == 0) break;
FordFulkerson ff(num_of_houses);
UnionFindTree uft(num_of_houses);
int bonus = 0;
for(int path_i = 0; path_i < num_of_paths; path_i++){
int from,to;
int cost;
scanf("%d %d %d",&from,&to,&cost);
if(cost < 0) bonus += cost;
ff.add_edge(from,to,max(0,cost));
uft.unite(from,to);
}
int tree_count = 0;
bool visited[101];
memset(visited,false,sizeof(visited));
for(int house_i = 0; house_i< num_of_houses; house_i++){
if(!visited[uft.find(house_i)]) tree_count++;
visited[uft.find(house_i)] = true;
}
int res = numeric_limits<int>::max();
if(tree_count >= 2){
res = 0;
}
else{
for(int house_i = 0; house_i< num_of_houses; house_i++){
int house_j = uft.find(house_i);
if(house_i == house_j) continue;
FordFulkerson tmp(ff);
res = min(res,tmp.compute_maxflow(house_i,house_j));
}
}
printf("%d\n",bonus + res);
}
}
|
// I'm the Topcoder
//C
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <math.h>
#include <time.h>
//C++
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <cctype>
#include <stack>
#include <string>
#include <list>
#include <queue>
#include <map>
#include <vector>
#include <deque>
#include <set>
using namespace std;
//*************************OUTPUT*************************
#ifdef WIN32
#define INT64 "%I64d"
#define UINT64 "%I64u"
#else
#define INT64 "%lld"
#define UINT64 "%llu"
#endif
//**************************CONSTANT***********************
#define INF 0x7F7F7F7F
#define eps 1e-8
#define PI acos(-1.)
#define PI2 asin (1.);
typedef long long LL;
//typedef __int64 LL; //codeforces
typedef unsigned int ui;
typedef unsigned long long ui64;
#define MP make_pair
typedef vector<int> VI;
typedef pair<int, int> PII;
#define pb push_back
#define mp make_pair
//***************************SENTENCE************************
#define CL(a,b) memset (a, b, sizeof (a))
#define sqr(a,b) sqrt ((double)(a)*(a) + (double)(b)*(b))
//****************************FUNCTION************************
template <typename T> double DIS(T va, T vb) { return sqr(va.x - vb.x, va.y - vb.y); }
template <class T> inline T INTEGER_LEN(T v) { int len = 1; while (v /= 10) ++len; return len; }
template <typename T> inline T square(T va, T vb) { return va * va + vb * vb; }
// aply for the memory of the stack
#pragma comment (linker, "/STACK:1024000000,1024000000")
//end
#define CY 105
typedef int typec;
bool inset[CY], vis[CY];
typec wage[CY];
int g[CY][CY];
int N, M;
typec Search(int n, int &s, int &t) {
memset(vis, false, n * sizeof(vis[0]));
memset(wage, 0, n * sizeof(wage[0]));
s = t = -1;
typec cf, mx;
int u = 0;
for (int i = 0; i < n; ++i) {
mx = -INF;
for (int j = 0; j < n; ++j) {
if (!inset[j] && !vis[j] && mx < wage[j]) {
mx = wage[u = j];
}
}
if (u == t) return cf;
s = t; t = u;
cf = mx;
vis[u] = true;
for (int v = 0; v < n; ++v) {
if (!inset[v] && !vis[v]) {
wage[v] += g[u][v];
}
}
}
return cf;
}
typec Stoer_Wagner(int n) {
int s, t;
typec ans = INF, cf;
memset(inset, false, n * sizeof(inset[0]));
for (int i = 1; i < n; ++i) {
cf = Search(n, s, t);
ans = min(ans, cf);
if (ans == 0) return ans;
inset[t] = true;
for (int j = 0; j < n; ++j) {
if (!inset[j] && j != s) {
g[s][j] += g[t][j];
g[j][s] += g[j][t];
}
}
}
return ans;
}
int main(void) {
while (2 == scanf("%d%d", &N, &M)) {
if (N == 0 && M == 0) break;
memset(g, 0, sizeof(g));
int ans = 0, u, v, c;
for (int i = 0; i < M; ++i) {
scanf("%d%d%d", &u, &v, &c);
if (c > 0) g[u][v] += c, g[v][u] += c;
else ans += c;
}
printf("%d\n", ans + Stoer_Wagner(N));
}
return 0;
}
|
#include <stdio.h>
#include <string.h>
#define MaxN 110
const int oo = 0x7fffffff;
int g[MaxN][MaxN], d[MaxN];
bool used[MaxN], vst[MaxN];
int main()
{
int min, n, m, max, tmp, pre, cur, a, b, w, cnt;
while (scanf("%d%d", &n, &m), n) {
min = oo, cnt = 0;
memset(g, 0, sizeof(g));
memset(used, 0, sizeof(used));
int Res = 0;
for (int i = 0; i < m; ++i) {
scanf("%d%d%d", &a, &b, &w);
if (w < 0){
Res += w;
continue;
}
g[a][b] += w;
g[b][a] = g[a][b];
}
if (n < 2) {
printf("%d\n",Res);
continue;
}
for (int i = 1; i < n; ++i) {
memset(vst, 0, sizeof(vst));
vst[0] = 1;
cur = pre = d[0] = 0;
for (int k = 1; k < n; ++k) d[k] = g[0][k];
for (int j = i; j < n; ++j) {
max = 0;
pre = cur;
for (int k = 0; k < n; ++k) {
if (vst[k] || used[k]) continue;
if (d[k] > max) {
max = d[k];
cur = k;
}
}
vst[cur] = 1;
for (int k = 0; k < n; ++k) {
if (vst[k] || used[k]) continue;
d[k] += g[cur][k];
}
}
used[cur] = 1;
for (int j = 0; j < n; ++j) {
if (j == pre || used[j]) continue;
g[pre][j] += g[cur][j];
g[j][pre] = g[pre][j];
}
tmp = 0;
for (int j = 0; j < n; ++j) {
if (used[j]) continue;
tmp += g[cur][j];
}
if (tmp < min) min = tmp;
else continue;
}
printf("%d\n", Res+min);
}
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cstring>
#include <cctype>
#include <algorithm>
#include <string>
#include <complex>
#include <list>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <sstream>
#include <numeric>
#include <functional>
#include <bitset>
#include <iomanip>
using namespace std;
#define INF (1<<29)
// math
#define Sq(x) ((x)*(x))
// container utility
#define ALL(x) (x).begin(), (x).end()
#define MP make_pair
#define PB push_back
#define EACH(it,c) for(__typeof((c).begin())it=(c).begin();it!=(c).end();it++)
// rep
#define REP(i,a,b) for(int i=a;i<b;i++)
#define rep(i,n) REP(i,0,n)
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
// typedef
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<PII> VII;
typedef vector<VI> VVI;
typedef long long ll;
// conversion
template<class T> inline string toStr(T a) { ostringstream oss; oss << a; return oss.str(); }
inline int toInt(string s) { return atoi(s.c_str()); }
// prime
bool isPrime(int a) { for(int i=2; i*i <=a; i++) if(a%i == 0) return false; return true; }
// !!! set MAX_L number !!!
#define MAX_L (1000001)
#define MAX_SQRT_B ((int)sqrt(INT_MAX)+1)
bool is_prime[MAX_L];
vector<bool> is_prime_small(MAX_SQRT_B);
void segment_sieve(ll a, ll b) {
for(int i=0; (ll)i*i < b; i++) is_prime_small[i] = true;
for(int i=0; i < b-a; i++) is_prime[i] = true;
if(a == 1) {
is_prime[0] = false;
}
is_prime_small[0] = is_prime_small[1] = false;
for(int i=2; (ll)i*i<b; i++) {
if(is_prime_small[i]) {
for(int j=2*i; (ll)j*j<b; j+=i) is_prime_small[j] = false;
for(ll j = max(2LL, (a+i-1)/i)*i; j<b; j+=i) is_prime[j-a] = false;
}
}
}
//////////////////////////////////////////////////////////////
struct Edge {
int to, cost, id;
Edge(int t, int c, int i)
: to(t), cost(c), id(i) {}
};
#define MAX_E (100)
vector<Edge> es[MAX_E];
int N, M;
bool isConnected(int x) {
vector<bool> used(N);
vector<int> VEC;
VEC.PB(0); used[0] = 1;
int v = 0;
while(!VEC.empty()) {
vector<int> NEXT;
EACH(i, VEC) {
EACH(e, es[*i]) {
if(e->id != x && !used[e->to]) {
used[e->to] = 1;
NEXT.PB(e->to);
}
}
v ++;
}
VEC = NEXT;
}
return N == v;
}
int main() {
while( cin >> N >> M && (N|M) ) {
for(int i=0; i<MAX_E; i++) {
es[i].clear();
}
int base = 0;
int id = 0;
vector<int> cost;
for(int i=0; i<M; i++) {
int s, t, c;
cin >> s >> t >> c;
if(c <= 0) base += c;
else {
es[s].PB(Edge(t, c, id));
es[t].PB(Edge(s, c, id));
cost.PB(c);
id ++;
}
}
int E = id;
int ans = INF;
if(!isConnected(-1)) ans = 0;
for(int i=0; i<E; i++) {
if(!isConnected(i)) ans = min(ans, cost[i]);
}
for(int i=0; i<E-1; i++)
for(int j=i+1; j<E; j++)
ans = min(ans, cost[i]+cost[j]);
cout << base + ans << endl;
}
return 0;
}
|
#define _USE_MATH_DEFINES
#define INF 100000000
#include <iostream>
#include <sstream>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
#include <map>
#include <string>
#include <cstring>
#include <set>
#include <deque>
#include <bitset>
#include <list>
#include <cstdio>
using namespace std;
typedef long long ll;
typedef pair <int,int> P;
typedef pair <int,P> PP;
static const double EPS = 1e-8;
const int tx[] = {0,1,0,-1};
const int ty[] = {-1,0,1,0};
struct Node {
int to;
int idx;
int flow;
Node(int to,int idx,int flow) :
to(to),idx(idx),flow(flow) {}
};
class FordFulkerson {
private:
vector<Node>* _graph;
bool* _used;
int _size;
int dfs(int src,int flow,int sink){
if(src == sink) return flow;
_used[src] = true;
for(int i= 0;i < _graph[src].size();i++){
Node& e = _graph[src][i];
if(_used[e.to]) continue;
if(e.flow <= 0) continue;
int d = dfs(e.to,min(flow,e.flow),sink);
if(d <= 0) continue;
Node& rev_e = _graph[e.to][e.idx];
e.flow -= d;
rev_e.flow += d;
return d;
}
return 0;
}
public:
FordFulkerson(int n) {
_size = n;
_graph = new vector<Node>[_size];
_used = new bool[_size];
}
FordFulkerson(const FordFulkerson& f){
_size = f.size();
_graph = new vector<Node>[_size];
_used = new bool[_size];
fill((bool*)_used,(bool*)_used + _size,false);
for(int i = 0; i < f.size(); i++){
for(int j = 0; j < f.graph()[i].size(); j++){
_graph[i].push_back(f.graph()[i][j]);
}
}
}
void add_edge(int from,int to,int flow) {
_graph[from].push_back(Node(to,_graph[to].size(),flow));
_graph[to].push_back(Node(from,_graph[from].size()-1,flow));
}
int compute_maxflow(int src,int sink){
int res = 0;
while(true){
fill((bool*)_used,(bool*)_used + _size,false);
int tmp = dfs(src,numeric_limits<int>::max(),sink);
if(tmp == 0) break;
res += tmp;
}
return res;
}
int size() const{
return _size;
}
vector<Node>* graph() const{
return _graph;
}
};
class UnionFindTree {
private:
int* par;
int* rank;
public:
UnionFindTree(int n){
par = new int[n]();
rank = new int[n]();
for(int i=0;i<n;i++){
par[i] = i;
rank[i] = 0;
}
}
~UnionFindTree(){
delete[] rank;
delete[] par;
}
int find(int x){
if(par[x] == x){
return x;
} else {
return par[x] = find(par[x]);
}
}
void unite(int x,int y){
x = find(x);
y = find(y);
if (x == y) return;
par[x] = y;
}
bool same(int x,int y){
return find(x) == find(y);
}
};
int main(){
int num_of_houses;
int num_of_paths;
while(~scanf("%d %d",&num_of_houses,&num_of_paths)){
if(num_of_houses == 0 && num_of_paths == 0) break;
FordFulkerson ff(num_of_houses);
UnionFindTree uft(num_of_houses);
int bonus = 0;
for(int path_i = 0; path_i < num_of_paths; path_i++){
int from,to;
int cost;
scanf("%d %d %d",&from,&to,&cost);
if(cost < 0) bonus += cost;
ff.add_edge(from,to,max(0,cost));
uft.unite(from,to);
}
int tree_count = 0;
bool visited[101];
memset(visited,false,sizeof(visited));
for(int house_i = 0; house_i< num_of_houses; house_i++){
if(!visited[uft.find(house_i)]) tree_count++;
visited[uft.find(house_i)] = true;
}
int res = numeric_limits<int>::max();
if(tree_count >= 2){
res = 0;
}
else{
for(int house_i = 0; house_i< num_of_houses; house_i++){
int house_j = uft.find(house_i);
if(house_i == house_j) continue;
FordFulkerson tmp(ff);
res = min(res,tmp.compute_maxflow(house_i,house_j));
}
}
printf("%d\n",bonus + res);
}
}
|
#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <cfloat>
#include <stack>
#include <queue>
#include <vector>
#include <string>
#include <iostream>
#include <set>
#include <map>
#include <time.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
#define NUM 100
struct Info{
Info(int arg_from,int arg_to,int arg_cost){
from = arg_from;
to = arg_to;
cost = arg_cost;
}
int from,to,cost;
};
int N,M;
int boss[100],height[100];
int get_boss(int id){
if(boss[id] == id)return id;
else{
return boss[id] = get_boss(boss[id]);
}
}
void unite(int x,int y){
int boss_x = get_boss(x);
int boss_y = get_boss(y);
if(boss_x == boss_y)return;
if(height[x] > height[y]){
boss[boss_y] = boss_x;
}else if(height[x] < height[y]){
boss[boss_x] = boss_y;
}else{ //height[x] == height[y]
boss[boss_y] = boss_x;
height[x]++;
}
}
void init(){
for(int i = 0; i < N; i++){
boss[i] = i;
height[i] = 0;
}
}
vector<Info> V;
void func(){
init();
V.clear();
int from,to,cost;
int ans = 0;
for(int i = 0; i < M; i++){
scanf("%d %d %d",&from,&to,&cost);
if(cost < 0){
ans += cost;
}else{
unite(from,to);
V.push_back(Info(from,to,cost));
}
}
int group_num = 0;
for(int i = 0; i < N; i++){
if(get_boss(i) == i)group_num++;
}
if(group_num >= 2){
printf("%d\n",ans);
return;
}
int ans_1 = BIG_NUM;
for(int i = 0; i < V.size(); i++){
init();
for(int k = 0; k < V.size(); k++){
if(i == k)continue;
unite(V[k].from,V[k].to);
}
group_num = 0;
for(int k = 0; k < N; k++){
if(get_boss(k) == k)group_num++;
}
if(group_num >= 2){
ans_1 = min(ans_1,ans+V[i].cost);
}
}
int ans_2 = BIG_NUM;
for(int i = 0; i < V.size()-1; i++){
for(int k = i+1; k < V.size(); k++){
init();
for(int p = 0; p < V.size(); p++){
if(p == i || p == k)continue;
unite(V[p].from,V[p].to);
}
group_num = 0;
for(int p = 0; p < N; p++){
if(get_boss(p) == p)group_num++;
}
if(group_num >= 2){
ans_2 = min(ans_2,ans+V[i].cost+V[k].cost);
}
}
}
printf("%d\n",min(ans_1,ans_2));
}
int main(){
while(true){
scanf("%d %d",&N,&M);
if(N == 0 && M == 0)break;
func();
}
return 0;
}
|
#define _USE_MATH_DEFINES
#define INF 100000000
#include <iostream>
#include <sstream>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
#include <map>
#include <string>
#include <cstring>
#include <set>
#include <deque>
#include <bitset>
#include <list>
#include <cstdio>
using namespace std;
typedef long long ll;
typedef pair <int,int> P;
typedef pair <int,P> PP;
static const double EPS = 1e-8;
const int tx[] = {0,1,0,-1};
const int ty[] = {-1,0,1,0};
struct Node {
int to;
int idx;
int flow;
Node(int to,int idx,int flow) :
to(to),idx(idx),flow(flow) {}
};
class FordFulkerson {
private:
vector<Node>* _graph;
bool* _used;
int _size;
int dfs(int src,int flow,int sink){
if(src == sink) return flow;
int res = 0;
_used[src] = true;
for(int i= 0;i < _graph[src].size();i++){
Node& e = _graph[src][i];
if(_used[e.to]) continue;
if(e.flow <= 0) continue;
int d = dfs(e.to,min(flow,e.flow),sink);
if(d > 0){
Node& rev_e = _graph[e.to][e.idx];
e.flow -= d;
rev_e.flow += d;
return d;
}
}
return 0;
}
public:
FordFulkerson(int n) {
_size = n;
_graph = new vector<Node>[_size];
_used = new bool[_size];
}
FordFulkerson(const FordFulkerson& f){
_size = f.size();
_graph = new vector<Node>[_size];
_used = new bool[_size];
fill((bool*)_used,(bool*)_used + _size,false);
for(int i = 0; i < f.size(); i++){
for(int j = 0; j < f.graph()[i].size(); j++){
_graph[i].push_back(f.graph()[i][j]);
}
}
}
void add_edge(int from,int to,int flow) {
_graph[from].push_back(Node(to,_graph[to].size(),flow));
_graph[to].push_back(Node(from,_graph[from].size()-1,flow));
}
int compute_maxflow(int src,int sink){
int res = 0;
while(true){
fill((bool*)_used,(bool*)_used + _size,false);
int tmp = dfs(src,numeric_limits<int>::max(),sink);
if(tmp == 0) break;
res += tmp;
}
return res;
}
int size() const{
return _size;
}
vector<Node>* graph() const{
return _graph;
}
};
class UnionFindTree {
private:
int* par;
int* rank;
public:
UnionFindTree(int n){
par = new int[n]();
rank = new int[n]();
for(int i=0;i<n;i++){
par[i] = i;
rank[i] = 0;
}
}
~UnionFindTree(){
delete[] rank;
delete[] par;
}
int find(int x){
if(par[x] == x){
return x;
} else {
return par[x] = find(par[x]);
}
}
void unite(int x,int y){
x = find(x);
y = find(y);
if (x == y) return;
par[x] = y;
}
bool same(int x,int y){
return find(x) == find(y);
}
};
int main(){
int num_of_houses;
int num_of_paths;
while(~scanf("%d %d",&num_of_houses,&num_of_paths)){
if(num_of_houses == 0 && num_of_paths == 0) break;
FordFulkerson ff(num_of_houses);
UnionFindTree uft(num_of_houses);
int bonus = 0;
for(int path_i = 0; path_i < num_of_paths; path_i++){
int from,to;
int cost;
scanf("%d %d %d",&from,&to,&cost);
if(cost < 0) bonus += cost;
ff.add_edge(from,to,max(0,cost));
uft.unite(from,to);
}
int tree_count = 0;
bool visited[101];
memset(visited,false,sizeof(visited));
for(int house_i = 0; house_i< num_of_houses; house_i++){
if(!visited[uft.find(house_i)]) tree_count++;
visited[uft.find(house_i)] = true;
}
int res = numeric_limits<int>::max();
if(tree_count >= 2){
res = 0;
}
else{
for(int house_i = 0; house_i< num_of_houses; house_i++){
int house_j = uft.find(house_i);
if(house_i == house_j) continue;
FordFulkerson tmp(ff);
res = min(res,tmp.compute_maxflow(house_i,house_j));
}
}
printf("%d\n",bonus + res);
}
}
|
#include<stdio.h>
#include<string.h>
long m,n,a,b,c;
long val[105];
long v[105][105];
int getans(){
int ans,i,j,k,r,s1,s2;
long a[105];
long mark[105];
long w[105];
memset(w,0,sizeof(w));
if (n==2){
return val[0];
}
a[0]=0;
for (i=0;i<n;i++)
mark[i]=1;
ans=val[a[0]];
for (i=1;i<=n-1;i++){
r=0;
mark[a[0]]=2;
for (j=0;j<n;j++){
if (mark[j]==1)
w[j]=v[a[0]][j];
}
while (true){
k=-1;
for (j=0;j<n;j++){
if (mark[j]==1 &&(k==-1 || w[j]>w[k]))
k=j;
}
if (k==-1)
break;
r++;
a[r]=k;
ans=ans<val[k]?ans:val[k];
mark[k]=2;
for (j=0;j<n;j++){
if (mark[j]==1)
w[j]+=v[j][k];
}
}
s1=a[r-1];s2=a[r];
val[s1]+=val[s2];
val[s1]-=v[s1][s2]*2;
mark[s2]=3;
for (j=0;j<n;j++){
if (mark[j]!=3){
v[s1][j]=v[j][s1]=v[s1][j]+v[j][s2];
mark[j]=1;
}
}
v[s1][s2]=v[s2][s1]=0;
}
return ans;
}
int main(){
while (scanf("%d %d",&n,&m)==2){
int nowans=0;
if (n==0)
return 0;
memset(val,0,sizeof(val));
memset(v,0,sizeof(v));
for (int j=0;j<m;j++){
scanf("%d %d %d",&a,&b,&c);
if (c<=0)
nowans+=c;
else{
v[a][b]=v[b][a]=v[a][b]+c;
val[a]+=c;
val[b]+=c;
}
}
printf("%d\n",nowans+getans());
}
}
|
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cstring>
#include <cctype>
#include <algorithm>
#include <string>
#include <complex>
#include <list>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <sstream>
#include <numeric>
#include <functional>
#include <bitset>
#include <iomanip>
using namespace std;
#define INF (1<<29)
// math
#define Sq(x) ((x)*(x))
// container utility
#define ALL(x) (x).begin(), (x).end()
#define MP make_pair
#define PB push_back
#define EACH(it,c) for(__typeof((c).begin())it=(c).begin();it!=(c).end();it++)
// rep
#define REP(i,a,b) for(int i=a;i<b;i++)
#define rep(i,n) REP(i,0,n)
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
// typedef
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<PII> VII;
typedef vector<VI> VVI;
typedef long long ll;
// conversion
template<class T> inline string toStr(T a) { ostringstream oss; oss << a; return oss.str(); }
inline int toInt(string s) { return atoi(s.c_str()); }
// prime
bool isPrime(int a) { for(int i=2; i*i <=a; i++) if(a%i == 0) return false; return true; }
// !!! set MAX_L number !!!
#define MAX_L (1000001)
#define MAX_SQRT_B ((int)sqrt(INT_MAX)+1)
bool is_prime[MAX_L];
vector<bool> is_prime_small(MAX_SQRT_B);
void segment_sieve(ll a, ll b) {
for(int i=0; (ll)i*i < b; i++) is_prime_small[i] = true;
for(int i=0; i < b-a; i++) is_prime[i] = true;
if(a == 1) {
is_prime[0] = false;
}
is_prime_small[0] = is_prime_small[1] = false;
for(int i=2; (ll)i*i<b; i++) {
if(is_prime_small[i]) {
for(int j=2*i; (ll)j*j<b; j+=i) is_prime_small[j] = false;
for(ll j = max(2LL, (a+i-1)/i)*i; j<b; j+=i) is_prime[j-a] = false;
}
}
}
//////////////////////////////////////////////////////////////
struct Edge {
int to, cost, id;
Edge(int t, int c, int i)
: to(t), cost(c), id(i) {}
};
#define MAX_E (300)
vector<Edge> es[MAX_E];
int N, M;
bool isConnected(int x) {
vector<bool> used(N);
vector<int> VEC;
VEC.PB(0); used[0] = 1;
int v = 0;
while(!VEC.empty()) {
vector<int> NEXT;
EACH(i, VEC) {
EACH(e, es[*i]) {
if(e->id != x && !used[e->to]) {
used[e->to] = 1;
NEXT.PB(e->to);
}
}
v ++;
}
VEC = NEXT;
}
return N == v;
}
int main() {
while( cin >> N >> M && (N|M) ) {
for(int i=0; i<MAX_E; i++) {
es[i].clear();
}
int base = 0;
int id = 0;
vector<int> cost;
for(int i=0; i<M; i++) {
int s, t, c;
cin >> s >> t >> c;
if(c <= 0) base += c;
else {
es[s].PB(Edge(t, c, id));
es[t].PB(Edge(s, c, id));
cost.PB(c);
id ++;
}
}
int E = id;
int ans = INF;
if(!isConnected(-1)) ans = 0;
for(int i=0; i<E; i++) {
if(!isConnected(i)) ans = min(ans, cost[i]);
}
for(int i=0; i<E-1; i++)
for(int j=i+1; j<E; j++)
ans = min(ans, cost[i]+cost[j]);
cout << base + ans << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
#define N 105
using namespace std;
struct edge{
int to, num;
};
int n, m;
vector<edge> G[N];
int A, B, minuscost;
int used[N], cost[N];
int dfs(int x){
if(used[x]) return 0;
used[x]=1;
int res=0;
for(int i=0;i<G[x].size();i++){
if(A==G[x][i].num) continue;
if(B==G[x][i].num) continue;
res+=dfs(G[x][i].to);
}
return res+1;
}
void solve(){
memset(used,0,sizeof(used));
A=-1, B=-1;
int nodesum=dfs(0);
if(nodesum!=n){
cout<<minuscost<<endl;
return ;
}
int ans=(1e9);
for(int i=0;i<m;i++){
A=i;
for(int j=i+1;j<m;j++){
B=j;
memset(used,0,sizeof(used));
int r=dfs(0);
if(r!=n) ans=min(ans, cost[A]+cost[B]+minuscost);
}
B=-1;
memset(used,0,sizeof(used));
int r=dfs(0);
if(r!=n) ans=min(ans, cost[A]+minuscost);
}
cout<<ans<<endl;
}
int main(){
while(1){
cin>>n>>m;
if(!n&&!m) break;
minuscost=0;
int cnt=0;
for(int i=0;i<m;i++){
int x, y, c;
cin>>x>>y>>c;
if(c<=0){
minuscost+=c;
continue;
}
cost[cnt]=c;
G[x].push_back((edge){y,cnt});
G[y].push_back((edge){x,cnt++});
}
m=cnt;
solve();
for(int i=0;i<n;i++) G[i].clear();
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
using Int = long long;
struct Fordfulerson{
const int INF = 1<<28;
struct edge{
int to,cap,rev;
edge(){};
edge(int to,int cap,int rev):to(to),cap(cap),rev(rev){};
};
int n;
vector<vector<edge> > G;
vector<int> used;
Fordfulerson(){};
Fordfulerson(int sz):n(sz),G(n),used(n){}
void add_edge(int from,int to,int cap){
G[from].push_back(edge(to,cap,G[to].size()));
G[to].push_back(edge(from,0,G[from].size()-1));
}
int dfs(int v,int t,int f){
if(v == t) return f;
used[v] = true;
for(int i=0;i<(int)G[v].size();i++){
edge &e = G[v][i];
if(!used[e.to] && e.cap > 0){
int d = dfs(e.to,t,min(f,e.cap));
if(d > 0){
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
int max_flow(int s,int t){
int flow = 0;
for(;;){
fill(used.begin(),used.end(),0);
int f = dfs(s,t,INF);
if(f == 0) return flow;
flow += f;
}
}
};
struct SCC{
int n;
vector<vector<int> > G,rG,T,C;
vector<int> vs,used,belong;
SCC(){};
SCC(int sz):n(sz),G(sz),rG(sz),used(sz),belong(sz){}
void add_edge(int from,int to){
G[from].push_back(to);
rG[to].push_back(from);
}
void dfs(int v){
used[v] = 1;
for(int i=0;i<(int)G[v].size();i++){
if(!used[G[v][i]]) dfs(G[v][i]);
}
vs.push_back(v);
}
void rdfs(int v,int k){
used[v] = 1;
belong[v] = k;
C[k].push_back(v);
for(int i=0;i<(int)rG[v].size();i++) {
if(!used[rG[v][i]]) rdfs(rG[v][i],k);
}
}
int build(){
fill(used.begin(),used.end(),0);
vs.clear();
for(int v=0;v<n;v++){
if(!used[v]) dfs(v);
}
fill(used.begin(),used.end(),0);
int k=0;
for(int i=vs.size()-1;i>=0;i--){
if(!used[vs[i]]){
T.push_back(vector<int>());
C.push_back(vector<int>());
rdfs(vs[i],k++);
}
}
return k;
}
};
struct UnionFind{
int n;
vector<int> r,p;
UnionFind(int n):n(n),r(n,1),p(n){iota(p.begin(),p.end(),0);}
int find(int x){
if(x==p[x]) return x;
return p[x]=find(p[x]);
}
void unite(int x,int y){
x=find(x);y=find(y);
if(x==y) return;
if(r[x]<r[y]) swap(x,y);
r[x]+=r[y];
p[y]=x;
}
};
signed main(){
cin.tie(0);
ios::sync_with_stdio(0);
int n,m;
while(cin>>n>>m,n){
vector<int> x(m),y(m),c(m);
int ans=0;
UnionFind uf(n);
SCC scc(n);
for(int i=0;i<m;i++){
cin>>x[i]>>y[i]>>c[i];
if(c[i]<=0) ans+=c[i];
else{
scc.add_edge(x[i],y[i]);
uf.unite(x[i],y[i]);
}
}
if(uf.r[uf.find(0)]!=n){
cout<<ans<<endl;
continue;
}
scc.build();
//cout<<ans<<endl;
auto b=scc.belong;
vector<int> v;
int t=-1;
for(int i=0;i<m;i++){
if(c[i]<=0) continue;
if(b[x[i]]==b[y[i]]){
v.emplace_back(c[i]);
continue;
}
if(t<0||c[i]<t) t=c[i];
}
sort(v.begin(),v.end());
if(!v.empty()&&(t<0||v[0]+v[1]<t)) t=v[0]+v[1];
cout<<ans+t<<endl;
}
return 0;
}
|
#include<iostream>
#include<cstdio>
#include<cmath>
#include<climits>
#include<ctime>
#include<cstdlib>
#include<vector>
#include<algorithm>
#include<cassert>
using namespace std;
#define REP(i,b,n) for(int i=b;i<n;i++)
#define rep(i,n) REP(i,0,n)
#define pb push_back
#define mp make_pair
#define ALL(C) (C).begin(),(C).end()
#define fi first
#define se second
const int N = 10000;
struct Edge{
int to,cost;
};
//solve connected graph
vector<int> edgeOnCycle;//only cost is enough
vector<int> edgeOnTree;//only cost is enough
int minEdgeOnCycle[2];//[0] < [1]
int minEdgeOnTree;
vector<Edge> edge[N];//
int dig[N];//for assertion
int vis[N];
bool dfs(int now,int color){
if (vis[now])return vis[now] == color;
vis[now]=color;
bool oncycle=false;
rep(i,(int)edge[now].size()){
bool tmp=dfs(edge[now][i].to,color);
if (tmp){
oncycle=true;
if (edge[now][i].cost < minEdgeOnCycle[0]){
minEdgeOnCycle[1]=minEdgeOnCycle[0];
minEdgeOnCycle[0]=edge[now][i].cost;
}else if (edge[now][i].cost < minEdgeOnCycle[1]){
minEdgeOnCycle[1]=edge[now][i].cost;
}
}else minEdgeOnTree=min(minEdgeOnTree,edge[now][i].cost);
}
return oncycle;
}
//find connect ?
vector<int> udedge[N];//undirect
void dfs2(int now){
if (vis[now])return;
vis[now]=true;
rep(i,(int)udedge[now].size()){
dfs2(udedge[now][i]);
}
}
bool isconnected(int n){
rep(i,n)vis[i]=0;
dfs2(0);
rep(i,n){
if (vis[i]==0)return false;
}
return true;
}
int solve(int n){
if (!isconnected(n))return 0;
int color=1;
rep(i,n)vis[i]=0;
rep(i,n){
if (vis[i] == 0)dfs(i,color),color++;
}
if (minEdgeOnCycle[0] == INT_MAX)return minEdgeOnTree;
return min(minEdgeOnCycle[0]+minEdgeOnCycle[1],minEdgeOnTree);
}
int main(){
int n,m;
while(cin>>n>>m && n){
rep(i,n){
udedge[i].clear();
edge[i].clear();
dig[i]=0;
}
edgeOnCycle.clear();
edgeOnTree.clear();
minEdgeOnCycle[0]=INT_MAX;
minEdgeOnCycle[1]=INT_MAX;
minEdgeOnTree=INT_MAX;
int ans=0;
rep(i,m){
int f,t,c;
cin>>f>>t>>c;
dig[t]++;
if (c <= 0){//elminate negative edge (also negative seledge)
ans+=c;//c<0
}else if (f == t){//ignore self edge of positive cost
}else {
edge[f].push_back((Edge){t,c});
udedge[f].push_back(t);
udedge[t].push_back(f);
}
}
rep(i,n)if (dig[i] >1)assert(false);
int sum=solve(n);
cout << ans+sum << endl;
}
return false;
}
|
#include <iostream>
#include <cstring>
#include <climits>
using namespace std;
void solve(string s,string key){
int left = 0, right = 0;
int n = s.length(), m = key.length();
int minLen = INT_MAX, cnt = 0;
string minStr = "";
int level[256];
bool flg[256];
memset(flg,0,sizeof(flg));
memset(level,0,sizeof(level));
for(int i=0;i<m;i++) flg[key[i]] = true;
int sum = 0;
while(1){
while(right < n && sum < m){
level[s[right]]++;
if(flg[s[right]] && level[s[right]] == 1){
sum++;
}
right++;
}
if(sum < m) break;
if(right - left < minLen){
minLen = right - left;
minStr = s.substr(left,right-left);
cnt = 1;
}
else if(right - left == minLen){
cnt++;
}
level[s[left]]--;
if(flg[s[left]] && level[s[left]] == 0){
sum--;
}
left++;
}
if(minLen == INT_MAX){
cout<<"0\n\n";
}
else{
cout<<cnt<<endl<<endl;
int i;
for(i=0;i<minStr.length();i++){
if(i != 0 && i % 72 == 0) cout<<endl;
cout<<minStr[i];
}
cout<<endl<<endl;
}
}
int main(void){
while(1){
string s,key;
while(1){
string tmp;
getline(cin,tmp);
if(tmp.empty()) break;
s += tmp;
}
if(s == "") break;
getline(cin,key);
solve(s,key);
getline(cin,s);
}
return 0;
}
|
#include<list>
#include<set>
#include<algorithm>
#include<iostream>
#include<string>
#include<cstdlib>
#include<cstring>
#include<cmath>
using namespace std;
int main(){
int i;
string s;
while(getline(cin, s)){
string t=s,u;
while(getline(cin,s)){
if(s.length()==0)
break;
t+=s;
}
if(t.length()==0)
break;
while(getline(cin,s)){
if(s.length()==0)
break;
u+=s;
}
/*
string s;
while(getline(cin,s)){
string t=s;
while(getline(cin,s)&&s!="")
t+=s;
string u;
getline(cin,u);
getline(cin,s);
*/
char z[256];
memset(z,0,sizeof(z));
int uln=u.length();
for(i=0;i<uln;i++)
z[(int)u[i]]=u[i];
list<pair<int,set<char> > > a;
int tln=t.length();
int imn;
unsigned nmn=-1;
int ct=0;
for(i=0;i<tln;i++){
if(z[(int)t[i]]){
set<char> b;
b.insert(t[i]);
a.push_back(make_pair(i,b));
list<pair<int,set<char> > >::iterator it;
for(it=a.begin();it!=a.end();it++){
(*it).second.insert(t[i]);
if((int)(*it).second.size()==uln){
if(nmn>(unsigned)(i-(*it).first+1)){
imn=(*it).first;
nmn=i-(*it).first+1;
ct=1;
}else if(nmn==(unsigned)(i-(*it).first+1)){
ct++;
}
it=a.erase(it);
it--;
}
}
}
}
if(nmn==(unsigned)-1){
cout<<0<<endl<<endl;
}else{
cout<<ct<<endl<<endl;
string v=t.substr(imn,nmn);
int vln=v.length();
for(i=0;i<vln/72;i++)
cout<<v.substr(i*72,72)<<endl;
if(vln%72)
cout<<v.substr(i*72)<<endl;
cout<<endl;
}
}
return 0;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <sstream>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <numeric>
#include <cctype>
#include <tuple>
#ifdef _MSC_VER
#include <agents.h>
#endif
#define FOR(i, a, b) for(int i = (a); i < (int)(b); ++i)
#define rep(i, n) FOR(i, 0, n)
#define ALL(v) v.begin(), v.end()
#define REV(v) v.rbegin(), v.rend()
#define MEMSET(v, s) memset(v, s, sizeof(v))
#define X first
#define Y second
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int valid[256];
int cnt[256];
int kind;
void add(char c){
if (!valid[c]) return;
if (cnt[c]++) return;
++kind;
}
void sub(char c){
if (!valid[c]) return;
if (--cnt[c]) return;
--kind;
}
int main(){
string str, key;
while (1){
str.clear();
key.clear();
while (true){
getline(cin, key);
if (key.empty() || !cin) break;
str += key;
}
if (str.empty() || !cin) break;
getline(cin, key);
cin.ignore();
//cout << str << endl;
//cout << key << endl;
MEMSET(cnt, 0);
MEMSET(valid, 0);
kind = 0;
for (auto &c : key) valid[c] = 1;
int n = str.size(), m = key.size();
int l = 0, r = 0;
int ans = n + 1;
int anscnt = 0;
P p;
while (1){
while (kind < m && r < n){
add(str[r++]);
}
if (kind == m){
if (r - l < ans){
ans = r - l;
p = make_pair(l, r);
anscnt = 1;
}
else if (r - l == ans){
++anscnt;
}
}
if (l >= r) break;
sub(str[l++]);
}
cout << anscnt << endl;
int chr = 0;
if (anscnt){
cout << endl;
for (int i = p.first; i < p.second; ++i){
cout << str[i];
++chr;
if (chr % 72 == 0) cout << endl;
}
if (chr % 72) cout << endl;
}
cout << endl;
}
return 0;
}
|
#include <set>
#include <iostream>
#include <sstream>
#include <vector>
#include <cstdio>
#include <algorithm>
#define REP(i,n) for(int i=0; i<(int)(n); i++)
#define FOR(i,c) for(__typeof((c).begin()) i=(c).begin(); i!=(c).end(); i++)
using namespace std;
int main(){
while(true){
stringstream ss;
string tmp;
if(!getline(cin, tmp)) break;
ss << tmp;
while(true){
getline(cin, tmp);
if(tmp == "") break;
ss << tmp;
}
string str = ss.str();
if(str.size() == 0) break;
string key; getline(cin, key);
vector<vector<int> > v(128);
vector<bool> f(128, false);
FOR(it, key) f[*it] = true;
REP(i, str.size()){
if(f[str[i]]){
v[str[i]].push_back(i);
}
}
int start = 0;
int end = str.size();
int cnt = 0;
REP(i, str.size()){
if(f[str[i]]){
int e = i + 1;
FOR(it, key) if(*it != str[i]){
vector<int>::iterator it2 =
lower_bound(v[*it].begin(), v[*it].end(), i + 1);
if(it2 == v[*it].end()) goto next;
e = max(e, *it2 + 1);
}
if(end - start > e - i){
start = i;
end = e;
cnt = 1;
}else if(end - start == e - i){
cnt++;
}
next:;
}
}
if(cnt){
printf("%d\n\n", cnt);
for(int i = 0; i + start < end; i++){
putchar(str[i + start]);
if(i % 72 == 72 - 1) puts("");
else if(i + start + 1 == end) puts("");
}
puts("");
}else{
puts("0"); puts("");
}
}
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <string>
#include <map>
#include <set>
using namespace std;
#define FOUND 1
#define NOT_FOUND -1
bool compare(string s1, string s2){
if(s1.size() == s2.size()) return s1 < s2;
return s1.size() < s2.size();
}
int main(){
string in, sub;
string seq;
bool flag = true;
while(getline(cin, in)){
if(!flag && (in.size() == 0 || cin.eof())){
if(cin.eof()) sub += in;
flag = true;
map<char, int > mp;
set<char> data;
for(int i = 0 ; i < sub.size() ; i++) data.insert(sub[i]);
for(int i = 0 ; i < sub.size() ; i++) mp[ sub[i] ] = NOT_FOUND;
int ans = 0;
int len = (1<<29);
string ans2;
for(int i = 0 ; i < seq.size() ; i++){
if(data.find(seq[i]) == data.end()) continue;
mp[ seq[i] ] = i;
int left = (1<<29);
bool ok = true;
for(int j = 0 ; j < sub.size() ; j++){
if(mp[ sub[j] ] == NOT_FOUND){
ok = false;
break;
}
left = min(left, mp[ sub[j] ]);
}
if(!ok) continue;
if(i - left == len) ans++;
if(i - left < len){
len = i - left;
ans = 1;
//cout << "i = " << i << " left = " << left << endl;
//cout << i << endl;
ans2 = seq.substr(left, i-left+1);
//cout << seq.substr(left, i-left+1) << endl;
}
}
cout << ans << endl << endl;
if(ans != 0){
for(int i = 0 ; i < ans2.size() ; i += 72){
cout << ans2.substr(i, 72) << endl;
}
if(!cin.eof()) cout << endl;
}
//cout << "ans_len = " << len << endl;
//cout << "ans_cnt = " << ans << endl;
//cout << "seq = " << seq << endl;
//cout << "sub = " << sub << endl;
//cout << endl;
seq = "", sub = "";
continue;
}
else if(flag && in.size() != 0){
seq += in;
continue;
}
else if(flag && in.size() == 0){
flag = false;
continue;
}
else if(!flag && in.size() != 0){
sub += in;
continue;
}
}
return 0;
}
|
#include<iostream>
#include<vector>
using namespace std;
#define REP(i,b,n) for(int i=b;i<n;i++)
#define rep(i,n) REP(i,0,n)
int need[255];
bool is_need[255];
void solve(string &a,int num){
pair<int,int> ans;
int tlength=a.size()+1,cnt=0;
int bef=0;
rep(i,a.size()){
if ( is_need[a[i]]==false)continue;
if ( need[a[i]]==0){
num--;
}
need[a[i]]++;
if ( need[a[i]] ){
while(bef<i){
if ( is_need[a[bef]]==0);
else if (need[a[bef]]<=is_need[a[i]])break;
else need[a[bef]]--;
bef++;
}
}
if ( num == 0 && 1+i-bef<=tlength){//update
if ( 1+i-bef < tlength){
cnt=0;
ans=make_pair(bef,i+1);
}
tlength=1+i-bef;
cnt++;
}
}
cout << cnt << endl;
if (cnt==0){puts("");return;}
for(int i=ans.first,j=0;i<ans.second;j++,i++){
if (j%72==0)puts("");
putchar(a[i]);
}
puts("");
puts("");
return;
}
int main(){
string t,a,target;
while(getline(cin,a) && a.size() !=0){
while(getline(cin,t) && t.size() != 0)a+=t;
getline(cin,target);
getline(cin,t);
rep(i,255)is_need[i]=0,need[i]=0;
rep(i,target.size())is_need[target[i]]=true;
solve(a,target.size());
}
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
string S,K;
const int n = 1<<8;
int getlen(){
int mx[n],res=1e9;
memset(mx,-1,sizeof(mx));
for(int i=0;i<S.size();i++){
int ch = S[i];
mx[ch] = max(mx[ch],i);
int c=0,l=1e9;
for(int j=0;j<K.size();j++)c+=mx[K[j]]>=0,l=min(l,mx[K[j]]);
if(c<K.size()) continue;
res=min(res,i-l);
}
return res;
}
int count(int len){
int cnt[n]={},res=0;
for(int i=0;i<S.size();i++){
cnt[S[i]]++;
int c=0;
for(int j=0;j<K.size();j++)c+=cnt[K[j]]>0;
if(c==K.size())res++;
if(i-len>=0) cnt[S[i-len]]--;
}
return res;
}
string getstr(int len){
int cnt[n]={},res=0;
for(int i=0;i<S.size();i++){
cnt[S[i]]++;
int c=0;
for(int j=0;j<K.size();j++)c+=cnt[K[j]]>0;
if(c==K.size()) return S.substr(i-len,len+1);
if(i-len>=0) cnt[S[i-len]]--;
}
return "";
}
int main(){
while(1){
S.clear();
while(1){
string s;
getline(cin,s);
if(s.empty()) break;
S+=s;
}
if(S.empty())break;
getline(cin,K);
int len = getlen();
cout<<count(len)<<endl;
string str = getstr(len);
for(int i=0;i<str.size();i++){
if(i!=str.size()-1&&i%72==0)cout<<endl;
cout<<str[i];
}
cout<<endl;
if(len<1e9)cout<<endl;
getline(cin,K);
}
return 0;
}
|
#include<iostream>
#include<cmath>
#include<cstdio>
#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
#define inf (1<<29)
using namespace std;
void compute(string text,string S)
{
int nt = text.size(),nS = S.size();
int mlen = inf;
string ans;
bool found[nS];
int CNT = 0;
int fpos[nS];
rep(i,nS)found[i] = false;
rep(i,nt)
{
bool update = false;
int cnt = 0,mn,mx;
mn = inf,mx = -inf;
rep(j,nS)
{
if(S[j] == text[i])
{
update = true;
found[j] = true;
fpos[j] = i;
}
if(found[j])
{
cnt++;
mn = min(mn,fpos[j]);
mx = max(mx,fpos[j]);
}
}
if(cnt == nS)
{
int cost = mx - mn + 1;
if(cost < mlen)
{
mlen = cost;
ans = text.substr(mn,cost);
CNT = 1;
}
else if(cost == mlen && update)CNT++;
}
}
cout << CNT << endl << endl;
if(!CNT)return;
rep(i,ans.size())
if((i+1)%72 == 0 && i != 0)
printf("%c\n",ans[i]);
else
printf("%c",ans[i]);
if(ans.size()%72 != 0)puts("\n");
else puts("");
}
int main()
{
string blank;
while(getline(cin,blank))
{
string text,S;
text += blank;
while(getline(cin,blank))
{
if(blank.empty())break;
text += blank;
}
if(text.empty())goto Fin;
while(getline(cin,blank))
if(blank.empty())break;
else S += blank;
compute(text,S);
}
Fin:;
return 0;
}
|
//47
#include<iostream>
#include<sstream>
#include<string>
#include<map>
#include<algorithm>
#include<set>
using namespace std;
int main(){
for(string si;getline(cin,si),si!="";){
string s;
do{
s+=si;
getline(cin,si);
}while(si!="");
string k;
getline(cin,k);
bool ap[128]={};
for(int i=0;i<k.size();){
if(ap[k[i]]++){
k.erase(i,1);
}else{
i++;
}
}
cin.ignore();
map<char,int> m;
int f=0,l=1<<30;
int n=0;
set<long long> st;
for(int i=0;i<s.size();i++){
for(int j=0;j<k.size();j++){
if(k[j]==s[i]){
m[s[i]]=i;
}
}
if(m.size()!=k.size())continue;
int cl=0,cf=1<<30;
for(int j=0;j<k.size();j++){
cl=max(cl,m[k[j]]);
cf=min(cf,m[k[j]]);
}
if(!st.insert((long long)cl<<32|cf).second)continue;
if(cl-cf<=l-f){
if(cl-cf<l-f){
f=cf;
l=cl;
n=0;
}
n++;
}
}
cout<<n<<endl<<endl;
if(n){
string t=s.substr(f,l-f+1);
for(int i=0;i<t.size();i+=72){
cout<<t.substr(i,72)<<endl;
}
cout<<endl;
}
}
return 0;
}
|
#include <iostream>
#include <sstream>
#include <string>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cassert>
using namespace std;
#define FOR(i,k,n) for(int i=(k); i<(int)(n); ++i)
#define REP(i,n) FOR(i,0,n)
#define FORIT(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
template<class T> void debug(T begin, T end){ for(T i = begin; i != end; ++i) cerr<<*i<<" "; cerr<<endl; }
inline bool valid(int x, int y, int W, int H){ return (x >= 0 && y >= 0 && x < W && y < H); }
typedef long long ll;
const int INF = 100000000;
const double EPS = 1e-8;
const int MOD = 1000000007;
int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
int main(){
bool begin = true;
while(true){
string s, text, query;
while(getline(cin, s) && s != ""){
text += s;
}
if(text == "") break;
getline(cin, query);
assert(query != "");
getline(cin, s); // empty
assert(s == "");
/*
if(begin) begin = false;
else cout << endl;
*/
int N = text.size();
int L = query.size();
map<char, int> to_idx;
REP(i, L) to_idx[query[i]] = i;
vector<int> idx_vec[100];
REP(i, N) if(to_idx.count(text[i])) idx_vec[to_idx[text[i]]].push_back(i);
bool ok = true;
REP(i, L) if(idx_vec[i].empty()) ok = false;
if(!ok){
cout << 0 << endl;
cout << endl;
continue;
}
map<int, set<int> > cnt;
int shortest_length = INF;
vector<int> cur(L);
while(true){
int b = idx_vec[0][cur[0]], e = idx_vec[0][cur[0]];
REP(i, L) {
b = min(b, idx_vec[i][cur[i]]);
e = max(e, idx_vec[i][cur[i]]);
}
int l = e - b + 1;
shortest_length = min(shortest_length, l);
if(shortest_length == l) cnt[l].insert(b);
int idx = -1;
REP(i, L)if(cur[i] + 1 < idx_vec[i].size()){
if(idx == -1 || idx_vec[i][cur[i] + 1] < idx_vec[idx][cur[idx] + 1]){
idx = i;
}
}
if(idx == -1) break;
cur[idx] += 1;
}
cout << cnt[shortest_length].size() << endl;
cout << endl;
string ans = text.substr(*cnt[shortest_length].begin(), shortest_length);
for(int i = 0; i < ans.size(); i += 72){
if(i + 72 < ans.size()) cout << ans.substr(i, 72) << endl;
else cout << ans.substr(i) << endl;
}
cout << endl;
}
return 0;
}
|
#include<cstdio>
#include<string>
#include<iostream>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
int main(){
while(1){
string s,tmp;
while(1){
getline(cin,tmp);
if(tmp=="") break;
s+=tmp;
}
string a; getline(cin,a);
getline(cin,tmp);
if(a=="") break;
int m=a.length();
bool b[128]={};
rep(i,m) b[a[i]]=true;
int n=s.length();
int j_ans,w_ans=2*n,c_ans=0;
int cnt[128]={},cnt2=0;
for(int i=0,j=0;i<n;i++){
if(cnt[s[i]]==0 && b[s[i]]) cnt2++;
cnt[s[i]]++;
// printf("i=%2d, j=%2d\n",i,j);
if(cnt2==m){
while(j<i && cnt[s[j]]>1 || cnt[s[j]]==1 && !b[s[j]]){
cnt[s[j]]--;
j++;
}
if(i-j+1<w_ans){
j_ans=j;
w_ans=i-j+1;
c_ans=1;
}
else if(i-j+1==w_ans){
c_ans++;
}
}
}
cout<<c_ans<<endl<<endl;
if(c_ans>0){
string ans=s.substr(j_ans,w_ans);
for(int i=0;i<w_ans;i+=72){
for(int j=i;j<min(i+72,w_ans);j++) cout<<ans[j];
cout<<endl;
}
cout<<endl;
}
}
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <complex>
#include <queue>
#include <map>
#include <set>
#include <cstring>
#include <cstdlib>
#include <string>
#include <cmath>
using namespace std;
#define REP(i,n) for(int i=0;i<(int)n;++i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()
const int INF = 1<<29;
int main() {
string s;
while(getline(cin,s)) {
if (s == "") break;
string t;
while(getline(cin,t), t!="")
s+=t;
string key;
while(getline(cin,t)) {
if (t=="") break;
key+=t;
}
// cout << "hoge" << endl;
// cout << s << " " << key << endl;
set<char> se;
map<char, int> mp;
FOR(it, key) {
se.insert(*it);
mp[*it] = -1;
}
int num = 0;
string res;
REP(i,s.size()) {
if (se.count(s[i])) {
mp[s[i]] = i;
bool f = 1;
int pos = INF;
FOR(it, mp) {
if (it->second < 0) f = 0;
pos = min(pos, it->second);
}
if (f) {
if (res == "" || i-pos+1 < res.size()) {
num = 1;
// cout << ";"<<pos<<" "<<s.size() << endl;
res = s.substr(pos, i-pos+1);
} else if (i-pos+1 == res.size())
num++;
}
}
}
cout << num << endl << endl;;
if (num) {
for (int i=0; i<res.size(); i+=72) {
// cout << min((int)s.size()-i,72) << endl;
cout << res.substr(i, min((int)res.size()-i,72)) << endl;;
}
cout << endl;
}
}
}
|
//47
#include<iostream>
#include<sstream>
#include<string>
#include<map>
#include<algorithm>
#include<set>
using namespace std;
int main(){
for(string si;getline(cin,si),si!="";){
string s;
do{
s+=si;
getline(cin,si);
}while(si!="");
string k;
getline(cin,k);
cin.ignore();
map<char,int> m;
int f=0,l=1<<30;
int n=0;
set<long long> st;
for(int i=0;i<s.size();i++){
for(int j=0;j<k.size();j++){
if(k[j]==s[i]){
m[s[i]]=i;
}
}
if(m.size()!=k.size())continue;
int cl=0,cf=1<<30;
for(int j=0;j<k.size();j++){
cl=max(cl,m[k[j]]);
cf=min(cf,m[k[j]]);
}
if(!st.insert((long long)cl<<32|cf).second)continue;
if(cl-cf<=l-f){
if(cl-cf<l-f){
f=cf;
l=cl;
n=0;
}
n++;
}
}
cout<<n<<endl<<endl;
if(n){
string t=s.substr(f,l-f+1);
for(int i=0;i<t.size();i+=72){
cout<<t.substr(i,72)<<endl;
}
cout<<endl;
}
}
return 0;
}
|
#include <iostream>
#include <string>
#include <map>
#include <algorithm>
using namespace std;
#define MAX (1<<24)
int main()
{
string s;
while(getline(cin,s))
{
string str(s), sb;
while(getline(cin, s))
{
if(s.size()==0) break;
str+=s;
}
if(str.size()==0) break;
while(getline(cin, s))
{
if(s.size()==0) break;
sb+=s;
}
int ansl=MAX, ret=0;
string ans;
map<char, int> d;
for(int i=0; i<str.size(); i++)
{
string::iterator it=find(sb.begin(), sb.end(), str[i]);
if(it==sb.end()) continue;
d[*it]=i;
int mi=MAX;
bool f=true;
for(int j=0; j<sb.size(); j++)
{
if(!d.count(sb[j]))
{
f=false;
break;
}
mi=min(mi, d[sb[j]]);
}
if(!f) continue;
if(i-mi < ansl)
{
ret=1;
ansl=i-mi;
ans.assign(str,mi,ansl+1);
}
else if(i-mi == ansl)
{
ret++;
}
}
cout << ret << endl;
if(ret!=0)
{
for(int i=0; i<ans.size(); i++)
{
if(i%72==0) cout << endl;
cout << ans[i];
}
cout << endl;
}
cout << endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
string buf;
while(getline(cin,buf),buf!=""){
string s=buf;
while(getline(cin,buf),buf!="") s+=buf;
string a;
getline(cin,a);
//cout<<s<<endl<<a<<endl;
int n=a.size();
vector<int> pos[n];
for(int i=0;i<(int)s.size();i++)
for(int j=0;j<n;j++)
if(s[i]==a[j]) pos[j].push_back(i);
bool f=1;
for(int i=0;i<n;i++) f&=!!(pos[i].size());
if(!f){
cout<<0<<endl<<endl;
getline(cin,buf);
continue;
}
int idx[n];
memset(idx,0,sizeof(idx));
int ans=0,len=s.size()+1,head=0;
for(int i=0;i<(int)s.size();i++){
int nxt=i;
for(int j=0;j<n;j++)
nxt=max(nxt,pos[j][idx[j]]);
if(nxt-i+1<len) ans=0,len=nxt-i+1,head=i;
if(nxt-i+1==len) ans++;
for(int j=0;j<n;j++){
if(s[i]==a[j]) idx[j]++;
if(idx[j]>=(int)pos[j].size()) goto LAB;
}
}
LAB:
string str=s.substr(head,len);
cout<<ans<<endl;
for(int i=0;i<(int)str.size();i++){
if(i%72==0) cout<<endl;
cout<<str[i];
}
cout<<endl<<endl;;
//ready for next;
getline(cin,buf);
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.