方法思路

1. 由于只能执行一次翻转操作，我们需要找到数组a和b中不同的部分
2. 首先从左到右找到第一个不同的位置start，从右到左找到最后一个不同的位置end
3. 如果将a的[start, end]区间翻转后能得到b，那么这个区间就是一个有效的翻转方案
4. 检查方法：a[start]应该等于b[end]，a[start+1]应该等于b[end-1]，以此类推
5. 如果区间两侧有相同的元素，那么可以扩展翻转区间，这会产生多个有效方案

代码实现

Java

import java.util.*;

public class Main {
    public static int calculate(int[] A, int[] B, int num) {
        // 找到第一个不同的位置
        int start = -1;
        for (int i = 0; i < num; i++) {
            if (A[i] != B[i]) {
                start = i;
                break;
            }
        }
        
        // 找到最后一个不同的位置
        int end = -1;
        for (int i = num - 1; i >= 0; i--) {
            if (A[i] != B[i]) {
                end = i;
                break;
            }
        }
        
        // 检查翻转区间[start, end]是否有效
        int indexA = start, indexB = end;
        while (indexA <= end && indexB >= start) {
            if (A[indexA] != B[indexB]) {
                return 0;
            }
            indexA++;
            indexB--;
        }
        
        // 计算有效方案数
        int res = 1;
        
        // 检查区间两侧是否有相同元素，可以扩展翻转区间
        int qian = start - 1;
        int hou = end + 1;
        while (qian >= 0 && hou < num) {
            if (A[qian] == A[hou]) {
                res++;
            } else {
                break;
            }
            qian--;
            hou++;
        }
        
        return res;
    }
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        int[] A = new int[num];
        int[] B = new int[num];
        for (int i = 0; i < num; i++) {
            A[i] = sc.nextInt();
        }
        for (int i = 0; i < num; i++) {
            B[i] = sc.nextInt();
        }
        System.out.println(calculate(A, B, num));
    }
}

Python

def calculate(A, B, num):
    # 找到第一个不同的位置
    start = -1
    for i in range(num):
        if A[i] != B[i]:
            start = i
            break
    
    # 找到最后一个不同的位置
    end = -1
    for i in range(num-1, -1, -1):
        if A[i] != B[i]:
            end = i
            break
    
    # 检查翻转区间[start, end]是否有效
    index_a, index_b = start, end
    while index_a <= end and index_b >= start:
        if A[index_a] != B[index_b]:
            return 0
        index_a += 1
        index_b -= 1
    
    # 计算有效方案数
    res = 1
    
    # 检查区间两侧是否有相同元素，可以扩展翻转区间
    qian = start - 1
    hou = end + 1
    while qian >= 0 and hou < num:
        if A[qian] == A[hou]:
            res += 1
        else:
            break
        qian -= 1
        hou += 1
    
    return res

# 读取输入
num = int(input())
A = list(map(int, input().split()))
B = list(map(int, input().split()))

# 计算并输出结果
print(calculate(A, B, num))

C++

#include <iostream>
#include <vector>
using namespace std;

int calculate(vector<int>& A, vector<int>& B, int num) {
    // 找到第一个不同的位置
    int start = -1;
    for (int i = 0; i < num; i++) {
        if (A[i] != B[i]) {
            start = i;
            break;
        }
    }
    
    // 找到最后一个不同的位置
    int end = -1;
    for (int i = num - 1; i >= 0; i--) {
        if (A[i] != B[i]) {
            end = i;
            break;
        }
    }
    
    // 检查翻转区间[start, end]是否有效
    int indexA = start, indexB = end;
    while (indexA <= end && indexB >= start) {
        if (A[indexA] != B[indexB]) {
            return 0;
        }
        indexA++;
        indexB--;
    }
    
    // 计算有效方案数
    int res = 1;
    
    // 检查区间两侧是否有相同元素，可以扩展翻转区间
    int qian = start - 1;
    int hou = end + 1;
    while (qian >= 0 && hou < num) {
        if (A[qian] == A[hou]) {
            res++;
        } else {
            break;
        }
        qian--;
        hou++;
    }
    
    return res;
}

int main() {
    int num;
    cin >> num;
    
    vector<int> A(num);
    for (int i = 0; i < num; i++) {
        cin >> A[i];
    }
    
    vector<int> B(num);
    for (int i = 0; i < num; i++) {
        cin >> B[i];
    }
    
    cout << calculate(A, B, num) << endl;
    
    return 0;
}