以下是用Python实现的回溯法代码：

定义一个全局变量，用于记录最短耗时

min_time = float('inf')

def cross_bridge(people, time, flashlight):
global min_time
# 如果所有人都已经过桥，更新最短耗时并返回
if not people:
min_time = min(min_time, time)
return
# 如果过桥耗时已经超过了最短耗时，直接返回
if time >= min_time:
return
# 遍历所有可能的人员组合
for i in range(len(people)):
for j in range(i+1, len(people)):
new_people = people[:]
new_people.remove(people[i])
new_people.remove(people[j])
new_flashlight = flashlight
# 计算过桥耗时
new_time = time + max(people[i], people[j])
# 如果有人需要拿手电过桥，更新new_flashlight
if people[i] != people[j] and flashlight == people[j]:
new_flashlight = people[i]
# 递归调用
cross_bridge(new_people, new_time, new_flashlight)

定义主函数

def main():
# 初始化人员和过桥耗时
people = [1, 3, 6, 8, 12]
time = 0
flashlight = 0
# 调用回溯函数
cross_bridge(people, time, flashlight)
# 输出最短耗时
print('最短耗时为：', min_time)

调用主函数

if name == 'main':
main()

以下是用C++实现的回溯法代码：

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

// 定义一个全局变量，用于记录最短耗时
int min_time = INT_MAX;

void cross_bridge(vector<int>& people, int time, int flashlight) {
// 如果所有人都已经过桥，更新最短耗时并返回
if (people.empty()) {
min_time = min(min_time, time);
return;
}
// 如果过桥耗时已经超过了最短耗时，直接返回
if (time >= min_time) {
return;
}
// 遍历所有可能的人员组合
for (int i = 0; i < people.size(); i++) {
for (int j = i+1; j < people.size(); j++) {
vector<int> new_people = people;
new_people.erase(new_people.begin()+j);
new_people.erase(new_people.begin()+i);
int new_flashlight = flashlight;
// 计算过桥耗时
int new_time = time + max(people[i], people[j]);
// 如果有人需要拿手电过桥，更新new_flashlight
if (people[i] != people[j] && flashlight == people[j]) {
new_flashlight = people[i];
}
// 递归调用
cross_bridge(new_people, new_time, new_flashlight);
}
}
}

int main() {
// 初始化人员和过桥耗时
vector<int> people = {1, 3, 6, 8, 12};
int time = 0;
int flashlight = 0;
// 调用回溯函数
cross_bridge(people, time, flashlight);
// 输出最短耗时
cout << "最短耗时为：" << min_time << endl;
return 0;
}

以下是修改后的C++代码，在回溯过程中记录过桥顺序：

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

// 定义一个全局变量，用于记录最短耗时和过桥顺序
int min_time = INT_MAX;
vector<pair<int, int>> cross_order;

void cross_bridge(vector<int>& people, int time, int flashlight, vector<pair<int, int>>& order) {
// 如果所有人都已经过桥，更新最短耗时和过桥顺序并返回
if (people.empty()) {
if (time < min_time) {
min_time = time;
cross_order = order;
}
return;
}
// 如果过桥耗时已经超过了最短耗时，直接返回
if (time >= min_time) {
return;
}
// 遍历所有可能的人员组合
for (int i = 0; i < people.size(); i++) {
for (int j = i+1; j < people.size(); j++) {
vector<int> new_people = people;
new_people.erase(new_people.begin()+j);
new_people.erase(new_people.begin()+i);
int new_flashlight = flashlight;
// 计算过桥耗时
int new_time = time + max(people[i], people[j]);
// 如果有人需要拿手电过桥，更新new_flashlight
if (people[i] != people[j] && flashlight == people[j]) {
new_flashlight = people[i];
}
// 更新过桥顺序
vector<pair<int, int>> new_order = order;
new_order.push_back(make_pair(people[i], people[j]));
// 递归调用
cross_bridge(new_people, new_time, new_flashlight, new_order);
}
}
}

int main() {
// 初始化人员和过桥耗时
vector<int> people = {1, 3, 6, 8, 12};
int time = 0;
int flashlight = 0;
vector<pair<int, int>> order;
// 调用回溯函数
cross_bridge(people, time, flashlight, order);
// 输出最短耗时和过桥顺序
cout << "最短耗时为：" << min_time << endl;
cout << "过桥顺序为：" << endl;
for (auto p : cross_order) {
cout << p.first << " " << p.second << endl;
}
return 0;
}