本文共 5232 字，大约阅读时间需要 17 分钟。

���������������Z������������������������������������������������������������������������������������������������������������������������������������������������������������

������������

���Z���������1���������������������������������n������������������i������������������������������������i���������A[i]������������Z���������������������������������������������������������������������������������������������������������������������������������������������������������n������������

������������

������������������

#include 
   
    
#include 
    
      //-for fabs
using namespace std;
// ������������������������������
void upperTrangle(vector
     
      
       >& a, int n) {
    double tmp;
    for (int i = 1; i <= n; i++) {
        int r = i;
        for (int j = i + 1; j <= n; j++)
            if (fabs(a[j][i]) > fabs(a[r][i]))
                r = j;
        if (r != i)
            for (int k = i; k <= n + 1; k++)
                swap(a[i][k], a[r][k]);
        for (int j = i + 1; j <= n; j++) {
            tmp = a[j][i] / a[i][i];
            for (int k = i; k <= n + 1; k++)
                a[j][k] -= a[i][k] * tmp;
        }
    }
}
// ���������������������������������Ax = b
void Gauss(vector
       
        
         >& a, int n) { upperTrangle(a, n); for (int i = n; i >= 1; i--) { for (int j = i + 1; j <= n; j++) a[i][n + 1] -= a[i][j] * a[j][n + 1]; a[i][n + 1] /= a[i][i]; } } // ���������p������������ vector
         
           findAdjacent(vector
          
           & edges, int p) { vector
           
             points; for (int i = 0; i < edges.size() / 2; ++i) { if (edges[2 * i] == p) points.push_back(edges[2 * i + 1]); else if (edges[2 * i + 1] == p) points.push_back(edges[2 * i]); } return points; } // ������������������ double func(int n, int hp, vector
            
             & damage, vector
             
              & edges) { // ���������dp������ vector
              
               
                > dp(hp + 1, vector
                
                 (n + 1, 0)); vector
                 
                  
                   > adjacentCount(n + 1, 0); for (int i = 0; i <= n; ++i) adjacentCount[i] = findAdjacent(edges, i).size(); dp[hp][1] = 1; // ������ for (int row = hp; row >= 1; --row) { // ������������������������������ // ������ductive damage[j] > 0������ for (int col = 1; col <= n; ++col) { if (damage[col - 1] > 0) { int current_damage = damage[col - 1]; vector
                   
                     preds = findAdjacent(edges, col); for (int p : preds) { if (p != n && (row + current_damage) <= hp) { dp[row][col] += dp[row + current_damage][p] / adjacentCount[p]; } } } } // ������������������������������������������������ vector
                    
                      zero_cols; // ��������������� for (int col = 1; col <= n; ++col) if (damage[col - 1] == 0) zero_cols.push_back(col); if (zero_cols.empty()) continue; // ������������������ vector
                     
                      
                       > matrix(zero_cols.size() + 1, vector
                       
                        (zero_cols.size() + 2, 0)); for (int k = 0; k < zero_cols.size(); ++k) { int col = zero_cols[k]; // ������������������������ matrix[k + 1][0] = -dp[row][col]; // ��������� for (int p : findAdjacent(edges, col)) { if (p != n && (row + damage[col - 1]) <= hp) { if (damage[p - 1] > 0) { // ��������������������� matrix[k + 1][k + 1] = matrix[k + 1][k + 1] - (dp[row][p] / adjacentCount[p]); } else { // ������������������ for (int m = 0; m < zero_cols.size(); ++m) { if (zero_cols[m] == p) { matrix[k + 1][m + 1] = (1.0 / adjacentCount[p]); break; } } } } } } // ��������������� Gauss(matrix, zero_cols.size()); for (int k = 0; k < zero_cols.size(); ++k) { int col = zero_cols[k]; dp[row][col] = matrix[k + 1][zero_cols.size() + 1]; } } // ������������������ double result = 0; for (int i = 1; i <= hp; ++i) result += dp[i][n]; return result; }
                       
                      
                     
                    
                   
                  
                 
                
               
              
             
            
           
          
         
        
       
      
     
    
   

������������

������������

��������������� n=3, hp=2, damage=[0,1,0], edges=[1,2,1,3,2,3]

• ���Z���������1���������������������������3���������������2���
• ������������2���������3���������������������������������2������������������������
• ���������������������0.875������1 - (1/8)���

���������

• ������������������������������������������������������������������������
• ������������������������������������������������������������������������
• ������������������������������������������������������

���������������������������������������������������������������������������������������������������������������������������������������������������������