Problem p00719 (C++) — buggy submission, verdict: Memory Limit Exceeded

#include <algorithm>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stdio.h>
#include <string>
#include <vector>

using namespace std;

#define EPS (1e-10)
#define EQ(a, b) (abs((a) - (b)) < EPS)
#define EQV(a, b) (EQ((a).real(), (b).real()) && EQ((a).imag(), (b).imag()))

typedef long long ll;

const int MAX_SIZE = 10000;

// struct edge{
//	int to;
//	int head;
// };

// vector<edge> G[31];

int d[31][31];
const int INF = 10000000;

int main() {
  int n, m, p, a, b;
  while ((cin >> n >> m >> p >> a >> b) &&
         !(n == 0 && m == 0 && p == 0 && a == 0 && b == 0)) {
    int tickets[10];
    for (int i = 0; i < n; i++)
      cin >> tickets[i];
    a--;
    b--;
    for (int i = 0; i < 31; i++)
      for (int j = 0; j < 31; j++)
        d[i][j] = -INF;
    for (int i = 0; i < p; i++) {
      int from, to, dist;
      cin >> from >> to >> dist;
      from--;
      to--;
      d[from][to] = dist;
      d[to][from] = dist;
    }
    double dp[31][1 << 8];
    int s = 0;
    for (int i = 0; i < n; i++) {
      if (tickets[i])
        s |= (1 << i);
    }

    for (int i = 0; i < 31; i++)
      for (int j = 0; j < (1 << 8); j++)
        dp[i][j] = INF;

    dp[a][(1 << n) - 1] = 0;
    for (int S = (1 << n) - 1; S >= 0; S--) {
      for (int u = 0; u < m; u++) {
        for (int i = 0; i < n; i++) {
          if (!(S & (1 << i)))
            continue;
          for (int v = 0; v < m; v++) {
            if (u == v || d[u][v] < 0)
              continue;
            if (u == a) {
              //		cout<<endl;
            }
            dp[v][S & ~(1 << i)] = min(dp[v][S & ~(1 << i)],
                                       dp[u][S] + (double)d[u][v] / tickets[i]);
          }
        }
      }
    }
    double minDist = INF;
    for (int i = 0; i < (1 << n); i++) {
      minDist = min(minDist, dp[b][i]);
    }
    if (EQ(minDist, INF))
      cout << "Impossible" << endl;
    else
      printf("%.6f\\n", minDist);
  }

  return 0;
}

// struct edge{
//	int to;
//	double cost;
//	int kipKind;
// };
//
//// ツノツーツドツづ個暗環置
// vector<edge> G[31][256];
// double d[31][256];
// const int INF = 1000000000;
//
//
// class Situation{
// public:
//	Situation(double _cost,int _node,int _used){
//		cost = _cost;
//		node = _node;
//		used = _used;
//	}
//
//	Situation();
//
//	double cost;
//	int node;
//	int used;
//
//	bool operator<(const Situation &sit)const{
//		return sit.cost < (this->cost);
//	}
// };
//
// void dijkstra(int s,int g){
//	priority_queue<Situation> que;
//
//	for(int i = 0; i < 31; i++)
//		fill(d[i],d[i]+256,INF);
//	d[s][0] = 0;
//
//	que.push(Situation(0.0,s,0));
//	while(!que.empty()){
//
//		Situation p = que.top();
//		que.pop();
//		int v = p.node;
//		int used = p.used;
//		if(d[v][used] < p.cost)
//			continue;
//		for(int i = 0; i < G[v][used].size(); i++){
//			edge e = G[v][used][i];
//			if(d[e.to][used | (1 << e.kipKind)] > d[v][used] +
//e.cost){
//
//					d[e.to][used | (1 << e.kipKind)] = d[v][used] +
//e.cost; 				que.push(Situation(d[e.to][used | (1 << e.kipKind)],e.to,(used | (1 <<
//e.kipKind))));
//			}
//		}
//
//	}
//	double minCost = INF;
//
//
//	for(int i = 0; i < 256; i++){
//		minCost = min(minCost,d[g][i]);
//	}
//	if(minCost != INF)
//		cout << minCost << endl;
//	else
//		cout << "Impossible" << endl;
// }
//
// int main(){
//
//
//	int n,m,p,a,b;
//	int cnt=0;
//	while((cin >> n >> m >> p >> a >> b) && !(n == 0 && m == 0 && p == 0 &&
//a == 0 && b == 0)){ 		int tickets[10]; 		for(int i = 0; i < n; i++) 			cin >>
//tickets[i]; 		for(int i = 0; i < 31; i++) 			for(int j = 0; j < 256; j++)
//				G[i][j].clear();
//
//		cnt++;
//		for(int i = 0; i < p; i++){
//			int to,from,cost;
//			cin >> from >> to >> cost;
//			from--;
//			to--;
//			for(int j = 0; j < (1 << n); j++){
//				for(int k = 0; k < n; k++){
//					// connect
//					edge e;
//					e.to = to;
//					e.cost = (double)cost/tickets[k];
//					e.kipKind = k;
//					if(((j >> k) & 1) == 0){
//						G[from][j].push_back(e);
//						e.to = from;
//						G[to][j].push_back(e);
//					}
//				}
//			}
//		}
//		if(cnt==2){
//			cout<<endl;
//		}
//		dijkstra(a-1,b-1);
//	}
//
//	return 0;
// }

Error: MLE

Fixed submission:

#include <algorithm>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <fstream>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stdio.h>
#include <string>
#include <vector>

using namespace std;

#define EPS (1e-10)
#define EQ(a, b) (abs((a) - (b)) < EPS)
#define EQV(a, b) (EQ((a).real(), (b).real()) && EQ((a).imag(), (b).imag()))

typedef long long ll;

const int MAX_SIZE = 10000;

struct edge {
  int to;
  double cost;
  int kipKind;
};

// ツノツーツドツづ個暗環置
vector<edge> G[31][256];
double d[31][256];
const int INF = 1000000000;

class Situation {
public:
  Situation(double _cost, int _node, int _used) {
    cost = _cost;
    node = _node;
    used = _used;
  }

  Situation();

  double cost;
  int node;
  int used;

  bool operator<(const Situation &sit) const { return sit.cost < (this->cost); }
};

void dijkstra(int s, int g) {
  priority_queue<Situation> que;

  for (int i = 0; i < 31; i++)
    fill(d[i], d[i] + 256, INF);
  d[s][0] = 0;

  que.push(Situation(0.0, s, 0));
  while (!que.empty()) {

    Situation p = que.top();
    que.pop();
    int v = p.node;
    int used = p.used;
    if (d[v][used] < p.cost)
      continue;
    for (int i = 0; i < G[v][used].size(); i++) {
      edge e = G[v][used][i];
      if (d[e.to][used | (1 << e.kipKind)] > d[v][used] + e.cost) {

        d[e.to][used | (1 << e.kipKind)] = d[v][used] + e.cost;
        que.push(Situation(d[e.to][used | (1 << e.kipKind)], e.to,
                           (used | (1 << e.kipKind))));
      }
    }
  }
  double minCost = INF;

  for (int i = 0; i < 256; i++) {
    minCost = min(minCost, d[g][i]);
  }
  if (minCost != INF)
    cout << minCost << endl;
  else
    cout << "Impossible" << endl;
}

int main() {

  int n, m, p, a, b;
  while ((cin >> n >> m >> p >> a >> b) &&
         !(n == 0 && m == 0 && p == 0 && a == 0 && b == 0)) {
    int tickets[10];
    for (int i = 0; i < n; i++)
      cin >> tickets[i];
    for (int i = 0; i < 31; i++)
      for (int j = 0; j < 256; j++)
        G[i][j].clear();

    for (int i = 0; i < p; i++) {
      int to, from, cost;
      cin >> from >> to >> cost;
      from--;
      to--;
      for (int j = 0; j < (1 << n); j++) {
        for (int k = 0; k < n; k++) {
          // connect
          edge e;
          e.to = to;
          e.cost = (double)cost / tickets[k];
          e.kipKind = k;
          if (((j >> k) & 1) == 0) {
            G[from][j].push_back(e);
            e.to = from;
            G[to][j].push_back(e);
          }
        }
      }
    }
    dijkstra(a - 1, b - 1);
  }

  return 0;
}