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

using namespace std;

static const double EPS = 1e-10;

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

void print_dist() {
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
      cout << dist[i][j] << " ";
    }
    cout << endl;
  }
  cout << endl;
}

void print_matrix() {
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
      cout << matrix[i][j] << " ";
    }
    cout << endl;
  }
  cout << endl;
}

int main() {
  while (scanf("%d %d %d", &n, &s, &e), n|s|e) {
  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();
  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]);
    //swap(gaus_in[x], gaus_in[pivot]);
//    if (pivot == s) {
//      cout << s << " " << x << endl;
//      s = x;
//    } else if (x == s) {
//      cout << s << " " << pivot << endl;
//      s = pivot;
//    }
    if (fabs(matrix[x][x]) < EPS) { continue; }
    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;
      }
      //gaus_in[y] += gaus_in[x] * ratio;
    }
  }
  for (int y = 0; y < n; y++) {
    for (int x = 0; x < y; x++) {
      assert(fabs(matrix[y][x]) < EPS);
    }
  }
  //print_matrix();
  for (int x = n - 1; x >= 0; x--) {
    double sum = gaus_in[x];
    for (int i = n - 1; i > x; i--) {
      sum -= ans[i] * matrix[x][i];
    }
    ans[x] = sum / matrix[x][x];
  }
//  for (int i = 0; i < n; i++) {
//    cout << ans[i] << endl;
//  }
  printf("%.8lf\n", ans[s]);
}
}

Measured memory_bytes: 1128