这个问题可以通过回溯法来解决。我们可以遍历所有可能的工作分配方案，然后找出总劳务费用最小的方案。

以下是C++代码实现：

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

const int INF = 1e9;
const int MAXN = 15;
int n;
int cost[MAXN][MAXN];
int dp[1 << MAXN];
int path[MAXN], bestPath[MAXN];
int minCost = INF;

void dfs(int u, int state, int sum) {
    if (sum >= minCost) return; // 剪枝
    if (u == n) {
        minCost = sum;
        copy(path, path + n, bestPath);
        return;
    }
    for (int i = 0; i < n; i++) {
        if (!(state >> i & 1)) {
            path[u] = i + 1;
            dfs(u + 1, state | 1 << i, sum + cost[u][i]);
        }
    }
}

int main() {
    cin >> n;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cin >> cost[i][j];
        }
    }
    dfs(0, 0, 0);
    cout << minCost << endl;
    for (int i = 0; i < n; i++) {
        cout << bestPath[i] << ' ';
    }
    return 0;
}

在这段代码中，我们首先读取输入的工作数n和每个工作的劳务费用。然后我们使用深度优先搜索遍历所有可能的工作分配方案。对于每个方案，我们计算总劳务费用，并更新最小总劳务费用和最佳工作分配方案。最后，我们输出最小总劳务费用和最佳工作分配方案。

这段代码的时间复杂度是O(n!)，因为我们需要遍历所有可能的工作分配方案。这段代码的空间复杂度是O(n)，因为我们需要存储每个工作的劳务费用和工作分配方案。