#include <climits>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;

template<class T> inline void chmin(T &a, const T &b) { if(a > b) a = b; }

typedef pair<int, int> edge;
#define to first
#define cost second

typedef vector<vector<edge>> graph;

constexpr long double EPS = 1e-10;

typedef vector<double> vec;
typedef vector<vec> mat;

vec gauss_jordan(const mat& A, const vec& b) {
	const int n = A.size();
	mat B(n, vec(n + 1));

	for(int i = 0; i < n; ++i) {
		for(int j = 0; j < n; ++j) {
			B[i][j] = A[i][j];
		}
		B[i][n] = b[i];
	}

	vector<int> idx(n);

	for(int i = 0; i < n; ++i) {
		int pivot = i;
		for(int j = i + 1; j < n; ++j) {
			if(abs(B[j][i]) > abs(B[pivot][i])) pivot = j;
		}
		B[i].swap(B[pivot]);

		if(abs(B[i][i]) < EPS) return vec();

		for(int j = i + 1; j <= n; ++j) {
			B[i][j] /= B[i][i];
		}

		for(int j = 0; j < n; ++j) {
			if(i != j) {
				for(int k = i + 1; k <= n; ++k) {
					B[j][k] -= B[j][i] * B[i][k];
				}
			}
		}
	}

	vec x(n);
	for(int i = 0; i < n; ++i) {
		x[i] = B[i][n];
	}

	return x;
}

vector<int> dijkstra(int s, const graph &G) {
	typedef pair<int, int> P;
	const int n = G.size();

	vector<int> dist(n, INT_MAX);
	priority_queue<P, vector<P>, greater<P>> que;

	dist[s] = 0;
	que.push({0, s});

	while(!que.empty()) {
		const int d = que.top().first;
		const int v = que.top().second;
		que.pop();

		if(dist[v] < d) continue;

		for(const auto &e : G[v]) {
			const int next_dist = d + e.cost;
			if(dist[e.to] > next_dist) {
				dist[e.to] = next_dist;
				que.push({next_dist, e.to});
			}
		}
	}


	return dist;
}

int main() {
	cin.tie(nullptr);
	ios::sync_with_stdio(false);
	cout.setf(ios::fixed);
	cout.precision(14);

	for(int n, s, t; cin >> n >> s >> t && n;) {
		--s; --t;

		vector<int> q(n);
		for(auto &e : q) cin >> e;

		graph G(n);
		for(int v = 0; v < n; ++v) {
			for(int u = 0; u < n; ++u) {
				int a;
				cin >> a;
				if(a) G[v].emplace_back(u, a);
			}
		}

		const auto dist = dijkstra(t, G);
		if(dist[s] == INT_MAX) {
			cout << "impossible" << endl;
			continue;
		}

		mat A(n, vec(n, 0.0));
		vec b(n, 0.0);

		for(int v = 0; v < n; ++v) {
			if(v == t) {
				A[t][t] = 1.0;
				continue;
			}

			if(dist[v] == INT_MAX) continue;

			for(const auto &e : G[v]) {
				if(q[v] && dist[v] != dist[e.to] + e.cost) continue;

				A[v][v] += 1.0;
				A[v][e.to] = -1.0;
				b[v] += e.cost;
			}
		}

		const auto ans = gauss_jordan(A, b);
		cout << ans[s] << endl;
	}

	return EXIT_SUCCESS;
}