first commit

Author: andreimargeloiu

1-sir.cpp

@@ -0,0 +1,32 @@
+ # include <fstream>
+ # include <algorithm>
+ # define mod 194767
+ # define NR 256*257/2+5
+ using namespace std;
+ ifstream f("1-sir.in");
+ ofstream g("1-sir.out");
+ int i,j,n,m,maxx,S;
+ int a[NR], b[NR];
+ int main ()
+ {
+     f>>n>>S;
+     if (n*(n+1)/2<S)
+     {
+         g<<"0\n";
+         return 0;
+     }
+
+     a[0]=1;
+     for (i=2; i<=n; ++i)
+     {
+         maxx=i*(i+1)/2;
+         for (j=0; j<=maxx; ++j)
+             b[j]=(a[j+(i-1)]+a[abs(j-(i-1))])%mod;
+
+         for (j=0; j<=maxx; ++j)
+            a[j]=b[j], b[j]=0;
+     }
+     g<<a[S]<<"\n";
+
+     return 0;
+ }

2ndesc.cpp

@@ -0,0 +1,49 @@
+# include <fstream>
+# include <algorithm>
+# define MOD 666013
+using namespace std;
+ifstream f("2ndesc.in");
+ofstream g("2ndesc.out");
+int i,j,n,m;
+int a[5], M[5][5], mat[5][5];
+void inmultire (int a[5][5], int b[5][5])
+{
+    int c[5][5];
+    for(int i=1; i<=3; ++i)
+        for (int j=1; j<=3; ++j) c[i][j]=0;
+
+    for (int i=1; i<=3; ++i) //linie a
+        for (int j=1; j<=3; ++j) //coloana b
+            for (int k=1; k<=3; ++k) //parcurgere
+                c[i][j]=(1LL*c[i][j] + 1LL*a[i][k]*b[k][j])%MOD;
+
+    for (int i=1; i<=3; ++i)
+        for (int j=1; j<=3; ++j)
+            a[i][j]=c[i][j];
+
+}
+int main ()
+{
+    f>>n;
+    a[1]=1; a[2]=2; a[3]=4;
+    if (n<=3) {g<<a[n]; return 0;}
+
+    mat[1][1]=1; mat[2][2]=1; mat[3][3]=1;
+    M[1][3]=1; M[2][1]=1; M[2][3]=1; M[3][2]=1; M[3][3]=1;
+    // ridicam logaritmic matricea la puterea n
+    n=n-3;
+    while (n) {
+        if (n%2==1) {
+            inmultire (mat, M);
+            --n;
+        }
+        else {
+                 inmultire (M, M);
+                 n=n/2;
+             }
+    }
+    g<<(mat[1][3] + 2*mat[2][3] + 4*mat[3][3])%MOD<<"\n";
+
+
+    return 0;
+}

3secv.cpp

@@ -0,0 +1,23 @@
+# include <fstream>
+# include <algorithm>
+using namespace std;
+ifstream f("3secv.in");
+ofstream g("3secv.out");
+int
+int main ()
+{
+    f>>n;
+    for (i=1; i<=n; ++i)
+        f>>a[i];
+
+
+    for (i=n-1; i>=1; --i)
+    {
+
+    }
+
+
+
+
+    return 0;
+}

APMD.cpp

@@ -0,0 +1,68 @@
+# include <fstream>
+# include <vector>
+# include <algorithm>
+# include <queue>
+# define inf 999999999
+using namespace std;
+ifstream f("apdm.in");
+ofstream g("apdm.out");
+queue <int> q;
+vector <int> v[155];
+int i,j,n,m,x,y,o,maxx,minn,maxim,S;
+int tata[155],ap[155],dist[155];
+void BF (int k)
+{
+    int i;
+    dist[k]=0; tata[k]=0; maxx=0;
+    q.push(k);
+    while (! q.empty())
+    {
+        k=q.front(); q.pop();
+        if (dist[k]>maxx) maxx=dist[k], S=k;
+        for (i=0; i<v[k].size(); ++i)
+        {
+            if (dist[k]+1<dist[v[k][i]])
+            {
+                dist[v[k][i]]=dist[k]+1;
+                tata[v[k][i]]=k;
+                q.push(v[k][i]);
+            }
+        }
+    }
+}
+void DFS (int k, int niv)
+{
+    if (niv>maxim) maxim=niv;
+    ap[k]=1;
+    for (int i=0; i<v[k].size(); ++i)
+    {
+        if (!ap[v[k][i]] && (tata[v[k][i]]==k || v[k][i]==tata[k]))
+        {
+            DFS (v[k][i], niv+1);
+        }
+    }
+}
+int main ()
+{
+    f>>n>>m;
+    for (i=1; i<=m; ++i)
+    {
+        f>>x>>y;
+        v[x].push_back(y);
+        v[y].push_back(x);
+    }
+    minn=inf;
+    for (o=1; o<=n; ++o)
+    {
+        for (j=1; j<=n; ++j)
+            dist[j]=inf,ap[j]=0;
+        BF (o);
+
+        maxim=0;
+        DFS (S,0);
+        if (maxim<minn) minn=maxim;
+    }
+    g<<minn<<"\n";
+
+    return 0;
+}

Andrei.cpp

@@ -0,0 +1,56 @@
+# include <fstream>
+# include <algorithm>
+# include <vector>
+using namespace std;
+ifstream f("andrei.in");
+ofstream g("andrei.out");
+struct elem
+{
+    int y, col;
+}E;
+vector <elem> v[100005];
+vector <int> visited;
+int i,j,n,m,x,y;
+int VV[100005], uz[100005];
+int DFS(int k, int tip)
+{
+    int i,nod,col;
+    if(uz[k])
+    {
+        if(VV[k]!=tip) return 0;
+        return 1;
+    }
+    visited.push_back(k); uz[k]=1; VV[k]=tip;
+    for(i=0; i<v[k].size(); ++i)
+    {
+        nod=v[k][i].y; col=v[k][i].col;
+        if(col==0 && tip==0) { if(! DFS(nod, 1)) return 0; }
+        if(col==1 && tip==1) { if(! DFS(nod, 0)) return 0; }
+        if(col==2)           { if(! DFS(nod, tip)) return 0; }
+    }
+    return 1;
+}
+int main ()
+{
+    f>>n>>m;
+    for (i=1; i<=m; ++i)
+    {
+        f>>x>>y>>E.col;
+        E.y=y; v[x].push_back(E);
+        E.y=x; v[y].push_back(E);
+    }
+    for(i=1; i<=n; ++i)
+        if(!uz[i])
+        {
+            if(! DFS(i, 0))
+            {
+                for (int o=0; o<visited.size(); ++o) uz[visited[o]]=0;
+                DFS(i, 1);
+            }
+        }
+
+    for(i=1; i<=n; ++i)
+        g<<VV[i]<<" ";
+
+    return 0;
+}

BMatrix.cpp

@@ -0,0 +1,4 @@
+#include <cstring>
+#include <fstream>
+#include <stack>
+using namespace std;  const int MAX_N = 202;  int N, M, sol; int H[MAX_N][MAX_N], D[MAX_N][MAX_N], dp[MAX_N][MAX_N]; char s[MAX_N]; bool A[MAX_N][MAX_N]; void read() {     ifstream f("bmatrix.in");      f >> N >> M;     for(int i = 1; i <= N; ++i) {         f >> s;         for(int j = 0; j < M; ++j)             if(s[j] == '0')                 A[i][j + 1] = 1;     }      f.close(); }  void solveLine(int line, int v[], int n) {     stack < pair < int, int > > st;      for(int i = 1; i <= n; ++i) {         if(st.empty() || v[i] > st.top().first)             st.push(make_pair(v[i], 1));         else if(st.top().first == v[i])             ++st.top().second;         else {             int cnt = 0;             while(!st.empty() && v[i] < st.top().first) {                 cnt += st.top().second;                 int top = st.top().first;                 st.pop();                 H[line][top] = max(H[line][top], cnt);             }             st.push(make_pair(v[i], cnt + 1));         }     }      int cnt = 0;     while(!st.empty()) {         cnt += st.top().second;         int top = st.top().first;         st.pop();         H[line][top] = max(H[line][top], cnt);     } }  void compute() {     memset(H, 0, sizeof(H));     memset(D, 0, sizeof(D));     for(int i = 1; i <= N; ++i) {         for(int j = 1; j <= M; ++j)             if(A[i][j])                 D[i][j] = D[i - 1][j] + 1;         solveLine(i, D[i], M);     }      for(int i = 1; i <= N; ++i) {         for(int j = i; j >= 1; --j)             H[i][j] = max(H[i][j], H[i][j + 1]);         dp[i][i] = H[i][1];     }     for(int h = 1; h < N; ++h)         for(int i = 1; i + h <= N; ++i) {             int j = i + h;             dp[i][j] = max(H[j][j - i + 1] * (j - i + 1), max(dp[i + 1][j], dp[i][j - 1]));         }      for(int i = 1; i < N; ++i)         sol = max(sol, dp[1][i] + dp[i + 1][N]); }  void transpose() {     int T[MAX_N][MAX_N];     memset(T, 0, sizeof(T));     for(int i = 1; i <= N; ++i)         for(int j = 1; j <= M; ++j)             T[j][i] = A[i][j];     swap(N, M);     memset(A, 0, sizeof(A));     for(int i = 1; i <= N; ++i)         for(int j = 1; j <= M; ++j)             A[i][j] = T[i][j]; }  void solve() {     compute();     transpose();     compute(); }  void write() {     ofstream g("bmatrix.out");      g << sol << "\n";      g.close(); }  int main() {     read();     solve();     write();      return 0; }

Bellman Ford cu BFS.cpp

@@ -0,0 +1,52 @@
+# include <fstream>
+# include <vector>
+# include <queue>
+# include <algorithm>
+# define inf 1000000000
+using namespace std;
+ifstream f("dijkstra.in");
+ofstream g("dijkstra.out");
+struct elem
+{
+    int y,val;
+}X,Y;
+vector <elem> v[50005];
+queue <int> q;
+int i,j,n,m,x,y;
+int dist[50005];
+void BFS ()
+{
+    int k,i;
+    q.push(1);
+    while (!q.empty())
+    {
+        k=q.front (); q.pop();
+        for (i=0; i<v[k].size(); ++i)
+        {
+            if (dist[v[k][i].y]>dist[k]+v[k][i].val)
+            {
+                dist[v[k][i].y]=dist[k]+v[k][i].val;
+                q.push(v[k][i].y);
+            }
+        }
+    }
+}
+int main ()
+{
+    f>>n>>m;
+    for (i=2; i<=n; ++i)
+        dist[i]=inf;
+    for (i=1; i<=m; ++i)
+    {
+        f>>x>>X.y>>X.val;
+        v[x].push_back(X);
+    }
+    BFS();
+    for (i=2; i<=n; ++i)
+    {
+        if (dist[i]==inf) g<<"0 ";
+        else g<<dist[i]<<" ";
+    }
+
+    return 0;
+}

CT.cpp

@@ -0,0 +1,88 @@
+# include <fstream>
+# include <algorithm>
+# include <cstring>
+# include <vector>
+# define NR 100005
+using namespace std;
+ifstream f("ct.in");
+ofstream g("ct.out");
+vector <int> v[NR];
+int i,j,n,m,x,y,sol,K,teste;
+int stiva[NR], niv[NR], T[NR][20], marcat[NR], lg[NR];
+struct elem {
+    int x, y, lca;
+}Q[NR];
+bool cmp (elem x, elem y) {
+    return niv[x.lca] > niv[y.lca];
+}
+void logaritmi () {
+    for (int i=2; i<=100000; ++i)
+        lg[i]=lg[i/2] + 1;
+}
+void DFS (int k, int tata, int nivel) {
+    niv[k]=nivel; stiva[nivel]=k;
+    //facem vecinii lui de la 2^i numvele in sus
+    for (int i=0; i<=lg[n] && (1<<i) < nivel; ++i)
+        T[k][i]=stiva[nivel - (1<<i)];
+
+    for (int i=0; i<v[k].size(); ++i)
+        if (v[k][i]!=tata) DFS (v[k][i], k, nivel+1);
+}
+int LCA (int X, int Y) {
+    if (niv[Y] > niv[X]) swap(X, Y);
+    // le aduc pe acelasi nivel
+    for (int j=lg[n]; j>=0 && niv[X]!=niv[Y]; --j)
+        if (niv[X] - (1<<j) >= niv[Y]) X=T[X][j];
+
+    if (X==Y) return X;
+    // urc simultan cu ele
+    for (int j=lg[n]; j>=0; --j)
+        if (T[X][j] != T[Y][j]) X=T[X][j], Y=T[Y][j];
+
+    return T[X][0];
+}
+void marcheaza (int k) {
+    marcat[k]=1;
+    for (int i=0; i<v[k].size(); ++i)
+        if (! marcat[v[k][i]] && v[k][i]!=T[k][0])
+            marcheaza (v[k][i]);
+}
+void init () {
+    for (int i=1; i<=n; ++i) {
+        v[i].clear ();
+        marcat[i]=0; niv[i]=0;
+        for (int j=0; j<=lg[n]; ++j)
+            T[i][j]=0;
+    }
+}
+int main ()
+{
+    logaritmi (); f>>teste;
+    for (int t=1; t<=teste; ++t) {
+        f>>n>>K; init ();
+
+        for (i=1; i<n; ++i) {
+            f>>x>>y;
+            v[x].push_back(y);
+            v[y].push_back(x);
+        }
+        DFS (1, 0, 1);
+
+        for (i=1; i<=K; ++i) {
+            f>>Q[i].x>>Q[i].y;
+            Q[i].lca=LCA (Q[i].x, Q[i].y);
+        }
+
+        sort (Q+1, Q+K+1, cmp);
+        sol=0;
+        for (i=1; i<=K; ++i)
+            if (! marcat[Q[i].x] && ! marcat[Q[i].y]) { // un nou punct
+                ++sol;
+                marcheaza (Q[i].lca);
+            }
+
+        g<<sol<<"\n";
+    }
+
+    return 0;
+}