#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <vector>
#include <math.h>
#include <assert.h>

using namespace std;

static const double EPS = 1e-10;

vector<double> GausElimination(vector<vector<double> > matrix, vector<double> vect) {
  const int n = vect.size();
  vector<double> ret(n, 0.0);
  for (int x = 0; x < n; x++) {
    int pivot = x;
    for (int i = x + 1; i < n; i++) {
      if (fabs(matrix[i][x]) - fabs(matrix[pivot][x]) > EPS) {
        pivot = i;
      }
    }
    swap(matrix[x], matrix[pivot]);
    if (fabs(matrix[x][x]) < EPS) { break; }
    for (int y = x + 1; y < n; y++) {
      double ratio = -matrix[y][x] /  matrix[x][x];
      matrix[y][x] = 0.0;
      for (int i = x + 1; i < n; i++) {
        matrix[y][i] += matrix[x][i] * ratio;
      }
    }
  }
  for (int x = n - 1; x >= 0; x--) {
    double sum = vect[x];
    for (int i = n - 1; i > x; i--) {
      sum -= ret[i] * matrix[x][i];
    }
    ret[x] = sum / matrix[x][x];
  }
  return ret;
}

int n, s, e;
int exist_sign[110];
int input[110][110];
int dist[110][110];
int road_num[110];
vector<vector<double> > matrix;
vector<double> gaus_in;
vector<double> ans;

int main() {
  while (scanf("%d %d %d", &n, &s, &e), n|s|e) {
  matrix.resize(n + 1);
  gaus_in.resize(n + 1);
  s--; e--;
  for (int i = 0; i < n; i++) {
    scanf("%d", &exist_sign[i]);
    matrix[i] = vector<double>(n + 1, 0.0);
  }
  matrix[n] = vector<double>(n + 1, 0.0);
  matrix[n][n] = 1.0;
  for (int y = 0; y < n; y++) {
    road_num[y] = 0;
    for (int x = 0; x < n; x++) {
      scanf("%d", &input[y][x]);
      if (input[y][x] != 0) {
        dist[y][x] = input[y][x];
        road_num[y]++;
      } else {
        dist[y][x] = 1000000;
      }
    }
    dist[y][y] = 0;
  }
  for (int k = 0; k < n; k++) {
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < n; j++) {
        dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
      }
    }
  }
  if (dist[s][e] == 1000000) {
    puts("impossible");
    return 0;
  }
  for (int y = 0; y < n; y++) {
    gaus_in[y] = 0.0;
    matrix[y][y] = -1;
    if (y == e) { continue; }
    int sum = 0;
    if (exist_sign[y]) {
      int min_dist = 900000;
      road_num[y] = 0;
      for (int x = 0; x < n; x++) {
        if (input[y][x] == 0) { continue; }
        if (input[y][x] + dist[x][e] < min_dist) {
          min_dist = input[y][x] + dist[x][e];
          road_num[y] = 1;
        } else if (input[y][x] + dist[x][e] == min_dist) {
          road_num[y]++;
        }
      }
      for (int x = 0; x < n; x++) {
        if (input[y][x] == 0) { continue; }
        if (input[y][x] + dist[x][e] != min_dist) { continue; }
        sum += input[y][x];
        matrix[y][x] = 1.0 / (double)road_num[y];
      }
    } else {
      for (int x = 0; x < n; x++) {
        if (input[y][x] == 0) { continue; }
        sum += input[y][x];
        matrix[y][x] = 1.0 / (double)road_num[y];
      }
    }
    if (road_num[y] != 0) {
      matrix[y][n] = (double)sum / (double)road_num[y];
      //cout << matrix[y][n] << endl;
    } else {
      matrix[y][n] = 100;
    }
  }
  //print_dist();
  gaus_in[n] = 1.0;
  n++;
  //print_matrix();
  ans = GausElimination(matrix, gaus_in);
  printf("%.8lf\n", ans[s]);
  }
}

Measured memory_bytes: 1216