Fixed some stuff

A*

@@ -0,0 +1,113 @@
+#include <iostream>
+#include <fstream>
+#include <queue>
+
+using namespace std;
+
+#define MAX_N 100
+#define INF 100000
+
+int dx[4] = {1, 0, -1, 0};
+int dy[4] = {0, 1, 0, -1};
+
+int dist(int crt_x, int crt_y, int fin_x, int fin_y) {
+	int dist_x = fin_x - crt_x;
+	int dist_y = fin_y - crt_y;
+
+	return (dist_x * dist_x + dist_y * dist_y);
+}
+
+int g[MAX_N][MAX_N];
+
+int main() {
+
+	ifstream in("Puzzle.in");
+
+  /*
+  TEST INPUT
+  4 4
+  0 0
+  3 3
+  1 1 1 0
+  0 1 0 0
+  0 1 1 0
+  1 0 1 1
+  */
+
+	int N, M;
+	int A[MAX_N][MAX_N];
+
+	int i, j;
+
+	in >> N >> M;
+
+	int start_x, start_y;
+	int stop_x, stop_y;
+
+	in >> start_x >> start_y;
+	in >> stop_x >> stop_y;
+
+	for(i = 1; i <= N; i ++)
+		for(j = 1; j <= M; j ++) {
+			in >> A[i][j];
+			g[i][j] = INF;
+		}
+
+	priority_queue<pair<int, pair<int, int> >,
+			 vector<pair<int, pair<int, int> > >,
+			 greater<pair<int, pair<int, int> > > > myPrioQueue;
+
+	start_x ++;
+	start_y ++;
+	stop_x ++;
+	stop_y ++;
+
+	g[start_x][start_y] = 0;
+
+	int new_x, new_y;
+
+	int f, h;
+
+	myPrioQueue.push(make_pair(0, make_pair(start_x, start_y)));
+
+	int current_x, current_y;
+	pair<int, pair<int, int> > current;
+
+	while(!myPrioQueue.empty()) {
+		current = myPrioQueue.top();
+		myPrioQueue.pop();
+
+		current_x = current.second.first;
+		current_y = current.second.second;
+
+		f = current.first;
+
+		for(i = 0; i < 4; i ++) {
+			new_x = current_x + dx[i];
+			new_y = current_y + dy[i];
+
+			if(new_x == 0 || new_x == N + 1 || new_y == 0 || new_y == M + 1 || !A[new_x][new_y])
+				continue;
+
+			h = dist(new_x, new_y, stop_x, stop_y);
+
+			if(g[new_x][new_y] > g[current_x][current_y] + 1) {
+
+				g[new_x][new_y] = g[current_x][current_y] + 1;
+
+				f = h + g[new_x][new_y];
+
+				myPrioQueue.push(make_pair(f, make_pair(new_x, new_y)));
+			}
+		}
+	}
+
+	cout << "Distances from source " << start_x << " " << start_y << " to destination " << stop_x << " " << stop_y << " are:\n";
+	for(i = 1; i <= N; i ++) {
+		for(j = 1; j <= M; j ++)
+			cout << g[i][j] << " ";
+		cout << "\n";
+	}
+
+	return 0;
+}

Balanced Brackets

@@ -0,0 +1,68 @@
+#include <bits/stdc++.h>
+#include <stack>
+#include <string>
+
+using namespace std;
+
+string isBalanced(string s) {
+    stack<int> myStack;
+    string::iterator it;
+
+    // Convention
+    // 1 ---> ( or )
+    // 2 ---> [ or ]
+    // 3 ---> { or }
+
+    for(it = s.begin(); it < s.end(); it ++) {
+        switch(*it) {
+            case '(' : 
+                myStack.push(1);
+                break;
+
+            case '[' : 
+                myStack.push(2);
+                break;
+
+            case '{' : 
+                myStack.push(3);
+                break;
+
+            case ')' : 
+                if(myStack.empty() || myStack.top() != 1)
+                    return "NO";
+                myStack.pop();
+                break;
+
+            case ']' : 
+                if(myStack.empty() || myStack.top() != 2)
+                    return "NO";
+                myStack.pop();
+                break;
+
+            case '}' : 
+                if(myStack.empty() || myStack.top() != 3)
+                    return "NO";
+                myStack.pop();
+                break;
+
+            default :
+                break;
+        }
+    }
+
+    if(myStack.empty())
+        return "YES";
+    return "NO";
+}
+
+int main() {
+    int t;
+    cin >> t;
+    for(int a0 = 0; a0 < t; a0++){
+        string s;
+        cin >> s;
+        string result = isBalanced(s);
+        cout << result << endl;
+    }
+    return 0;
+}

Bellman-Ford

@@ -0,0 +1,74 @@
+#include <iostream>
+#include <fstream>
+#include <vector>
+#include <queue>
+
+using namespace std;
+
+#define NMAX 100
+#define INF 100000
+vector<pair<int, int> > G[NMAX];
+
+vector<pair <pair <int, int>, int > > Edges; 
+
+int d[NMAX];
+int N, M;
+
+void Bellman(int sursa) {
+
+    int i, j;
+    pair<int, int> u;
+
+    priority_queue <pair<int, int>, vector<pair<int, int> >, greater<pair<int, int> > > Q;
+
+    // std::fill(d.begin(), d.end(), INF);
+    for(i = 1; i <= N; i ++)
+        d[i] = INF;
+    d[sursa] = 0;
+    Q.push(make_pair(0, sursa));
+
+   for(i = 1; i <= N-2; i ++) {
+        for(pair<pair <int, int>, int> m : Edges) {
+            pair<int, int> edge = m.first;
+            int cost = m.second;
+
+            if(d[edge.second] > d[edge.first] + cost)
+                d[edge.second] = d[edge.first] + cost;
+
+            }
+
+   }
+
+        for(pair<pair <int, int>, int> m : Edges) {
+            pair<int, int> edge = m.first;
+            int cost = m.second;
+
+            if(d[edge.second] > d[edge.first] + cost)
+                cout << "Ciclu negativ\n";
+
+            }
+
+
+}    
+
+int main(){
+
+    int i, j;
+    int x, y, c;
+
+    int start;
+
+    ifstream in("in1.txt");
+
+    in >> N >> M;
+    for(i = 1; i <= M; i ++) {
+        in >> x >> y >> c;
+        Edges.push_back(make_pair(make_pair(x,y), c));
+        }
+
+    start = 1;
+
+    Bellman(start);
+
+    return 0;
+}

Dijkstra

@@ -0,0 +1,68 @@
+#include <iostream>
+#include <fstream>
+#include <vector>
+#include <queue>
+
+using namespace std;
+
+#define NMAX 100
+#define INF 100000
+vector<pair<int, int> > G[NMAX];
+
+int d[NMAX];
+int N, M;
+
+void Dijkstra(int sursa) {
+
+    int i, j;
+    pair<int, int> u;
+
+    priority_queue <pair<int, int>, vector<pair<int, int> >, greater<pair<int, int> > > Q;
+
+    for(i = 1; i <= N; i ++)
+        d[i] = INF;
+    d[sursa] = 0;
+    Q.push(make_pair(0, sursa));
+
+    while(!Q.empty()) {
+        u = Q.top();
+        Q.pop();
+
+        for(i = 0; i < G[u.second].size(); i ++) {
+
+
+            if( d[G[u.second][i].second] > d[u.second] + G[u.second][i].first) {
+                d[G[u.second][i].second] = d[u.second] + G[u.second][i].first;
+                 Q.push(G[u.second][i]);
+            }
+        }
+   }
+
+}    
+
+int main(){
+
+    int i, j;
+    int x, y, c;
+
+    int start;
+    ifstream in("in1.txt");
+
+    in >> N >> M;
+    for(i = 1; i <= M; i ++) {
+        in >> x >> y >> c;
+        G[x].push_back(make_pair(c, y));
+    }
+
+    // in >> start;    
+    start = 1;
+
+    Dijkstra(start);
+
+    for(i = 1; i <= N; i ++)
+        cout << d[i] << " ";
+
+    cout << "\n";
+
+    return 0;
+}