#include <bits/stdc++.h>
#define int long long
using namespace std;

template<class T>
struct Matrix{
	vector<vector<T>> A;
	Matrix(int n) : A(n,vector<T>(n,T(0))){}
	Matrix(int n,int m) : A(n,vector<T>(m,T(0))){}

	int size() const{ return A.size(); }
	vector<T> &operator[](const int k){ return A[k]; }
	const vector<T> &operator[](const int k) const{ return A[k]; }
	Matrix operator*(const T &x) const{ Matrix(*this) *= x; }
	Matrix operator*(const Matrix &B) const{ Matrix(*this) *= B; }
	
	Matrix &operator*=(const T &x){
		for(int i = 0;i < A.size();i++){
			for(int j = 0;j < A[0].size();j++) A[i][j] *= x;
		}
		return *this;
	}

	Matrix &operator*=(const Matrix &B) {
		assert(A[0].size() == B.size());
		vector<vector<T>> C(A.size(),vector<T>(B[0].size(),T(0)));
		for(int i = 0;i < A.size();i++){
			for(int k = 0;k < B.size();k++){
				for(int j = 0;j < B[0].size();j++) C[i][j] += A[i][k] * B[k][j];
			}
		}
		A.swap(C);
		return *this;
	}

	vector<T> operator*(const vector<T> &v) const{
		assert(A[0].size() == v.size());
		vector<T> ret(A.size());
		for(int i = 0;i < A.size();i++){
			for(int j = 0;j < v.size();j++) ret[i] += A[i][j] * v[j];
		}
		return ret;
	}

	Matrix pow(long long x) const{
		assert(A.size() == A[0].size());
		Matrix ret = E(A.size()),tmp = *this;
		for(;x;tmp *= tmp,x >>= 1){
			if(x & 1) ret *= tmp;
		}
		return ret;
	}

	static Matrix E(int n){
		Matrix ret(n);
		for(int i = 0;i < n;i++) ret[i][i] = T(1);
		return ret;
	}
};

template<class T>
int gauss_jordan(Matrix<T> &A,bool is_extended = false){
	int n = A.size(),m = A[0].size(),rnk = 0;
	for(int i = 0;i < m;i++){
		if(is_extended && i == m - 1) break;
		int pivot = -1;
		for(int j = rnk;j < n;j++){
			if(A[j][i] != T(0)){
				pivot = j;
				break;
			}
		}
		if(pivot == -1) continue;
		swap(A[pivot],A[rnk]);
		for(int j = m - 1;j >= i;j--) A[rnk][j] /= A[rnk][i];
		for(int j = 0;j < n;j++){
			if(j == rnk) continue;
			for(int k = m - 1;k >= i;k--) A[j][k] -= A[j][i] * A[rnk][k];
		}
		rnk++;
	}
	return rnk;
}

template<class T>
tuple<vector<T>,bool,int> linear_equation(const Matrix<T> &A,const vector<T> &b){
	int n = A.size(),m = A[0].size();
	Matrix<T> B(n,m + 1);
	for(int i = 0;i < n;i++){
		for(int j = 0;j < m;j++) B[i][j] = A[i][j];
		B[i][m] = b[i];
	}
	int rnk = gauss_jordan(B,true);
	vector<T> ret(n);
	for(int i = 0;i < n;i++) ret[i] = B[i][m];
	for(int i = rnk;i < n;i++){
		if(B[i][m] != T(0)) return make_tuple(ret,false,rnk);
	}
	return make_tuple(ret,true,rnk);
}

template<class T>
void warshallFloyd(Matrix<T> &G){
	for(int k = 0;k < G.size();k++){
		for(int i = 0;i < G.size();i++){
			for(int j = 0;j < G.size();j++){
				G[i][j] = min(G[i][j],G[i][k] + G[k][j]);
			}
		}
	}
}

int n,s,t;

void solve(){
	const int INF = 1e+9;
	int q[110];
	s--;t--;
	for(int i = 0;i < n;i++) cin >> q[i];
	Matrix<int> a(n),b(n);
	for(int i = 0;i < n;i++){
		for(int j = 0;j < n;j++){
			cin >> a[i][j];
			b[i][j] = a[i][j];
			if(!a[i][j]) b[i][j] = INF;
		}
	}
	b[t][t] = 0;
	warshallFloyd(b);
	if(b[s][t] == INF){
		cout << "impossible" << endl;
		return;
	}
	Matrix<double> A(n);
	vector<double> v(n);
	for(int i = 0;i < n;i++){
		if(i == t) A[i][i] = 1;
		else{
			for(int j = 0;j < n;j++){
				if(a[i][j] && (!q[i] || a[i][j] + b[j][t] == b[i][t])){
					A[i][j] -= 1;
					A[i][i] += 1;
					v[i] += a[i][j];
				}
			}
		}
	}
	auto ans = get<0>(linear_equation(A,v));
	printf("%.15lf\n",ans[s]);
}

signed main(){
	while(cin >> n >> s >> t,n) solve();
}


Measured memory_bytes: 3244