c++bool转化cstring

在 C++ 中，将 `bool` 类型转换成 `const char*` 或 `std::string` 的常见做法是使用字符串连接符 `""` 和对应的布尔值表示。当 `bool` 为真（`true`）时，通常会映射到 "true" 或 "1"；当为假（`false`）时，可以映射到 "false" 或 "0"。下面是一个简单的例子：

bool isTrue = true;
const char* boolToString(bool value) {
    return value ? "true" : "false";
}

std::string boolToStr(bool value) {
    return value ? "true" : "false"; // 使用更现代的方式
}

// 转换为 const char*
const char* strFromBool = boolToString(isTrue);

// 或者转换为 std::string
std::string strFromBoolStr = boolToStr(isTrue);

相关问题

用c++语言编写程序实现单纯形法求解

单纯形法是一种线性规划求解方法，可以通过以下步骤来实现：

1. 将线性规划问题转化为标准形式，即将目标函数转化为最小化形式，将不等式约束转化为等式约束，并引入人工变量。

2. 构造初始单纯形表格，包括目标函数系数、人工变量系数、约束系数以及松弛变量系数等信息。

3. 判断当前单纯形表格是否为最优解，如果是，则结束计算；否则，选择进入变量和离开变量进行行变换。

4. 根据选定的进入变量和离开变量进行行变换，得到新的单纯形表格。

5. 重复步骤3和4，直到找到最优解或者确定问题无解。

以下是一个用c++语言实现单纯形法求解线性规划问题的示例代码：

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

const int N = 110, M = 1010;
const double INF = 1e10, eps = 1e-8;

int n, m;
double a[N][M], b[N], c[M];
int id[M];
bool is_basic[N];

void pivot(int r, int c)
{
    b[r] /= a[r][c];
    for (int j = 0; j <= m; j ++ )
        if (j != c) a[r][j] /= a[r][c];
    a[r][c] = 1;

    for (int i = 0; i <= n; i ++ )
        if (i != r && fabs(a[i][c]) > eps)
        {
            b[i] -= a[i][c] * b[r];
            for (int j = 0; j <= m; j ++ )
                if (j != c) a[i][j] -= a[i][c] * a[r][j];
            a[i][c] = -a[i][c] * a[r][c];
        }

    is_basic[id[c]] = true;
    is_basic[id[m - n + r]] = false;
    id[c] = m - n + r;
}

double simplex()
{
    while ( true )
    {
        int c = 0;
        for (int i = 1; i < m; i ++ )
            if (c == 0 || c[id[i]] > c[id[c]]) c = i;
        if (c == 0) break;

        int r = 0;
        double t = INF;
        for (int i = 1; i <= n; i ++ )
            if (a[i][c] > eps && b[i] / a[i][c] < t)
            {
                t = b[i] / a[i][c];
                r = i;
            }
        if (r == 0) return INF;

        pivot(r, c);
    }

    while ( true )
    {
        int r = 0;
        for (int i = 1; i <= n; i ++ )
            if (!is_basic[i] && (r == 0 || b[i] < b[r])) r = i;
        if (r == 0) break;

        int c = 0;
        for (int i = 1; i < m; i ++ )
            if (a[r][i] < -eps && (!c || (rand() & 1))) c = i;
        if (c == 0)
            for (int i = 1; i < m; i ++ )
                if (a[r][i] < -eps) { c = i; break; }

        if (c == 0) return INF;

        pivot(r, c);
    }
    return -b[0];
}

int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i ++ ) scanf("%lf", &b[i]);
    for (int i = 1; i <= m; i ++ ) scanf("%lf", &c[i]);

    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= m; j ++ )
            scanf("%lf", &a[i][j]);

    for (int i = 1; i <= m; i ++ ) id[i] = i;
    double res = simplex();
    if (res >= INF) puts("Infeasible"); // 无解
    else if (res <= -INF) puts("Unbounded"); // 无界
    else printf("%.lf\n", res);

    return 0;
}

使用方式：输入n，m，b数组，c数组和a数组，其中n是变量个数，m是约束个数，b数组是约束的右侧常数，c数组是目标函数的系数，a数组是约束的系数矩阵。输出最优解或无解或无界。

分支限界法之最小权顶点覆盖问题c++实现

最小权顶点覆盖问题可以转化为最大匹配问题，而最大匹配问题可以使用匈牙利算法解决。以下是使用分支限界法解决最小权顶点覆盖问题的c++代码示例：

#include <iostream>
#include <queue>
#include <cstring>
using namespace std;

const int MAXN = 1005;
const int INF = 0x3f3f3f3f;

int n, m, ans = INF;
int w[MAXN][MAXN]; // 权值矩阵
int lx[MAXN], ly[MAXN], slack[MAXN]; // 顶标数组
int link[MAXN], visx[MAXN], visy[MAXN]; // 匈牙利算法中的变量

struct Node {
    int u, v, w;
    bool operator < (const Node& a) const {
        return w > a.w;
    }
};

void init() {
    memset(link, -1, sizeof(link));
    memset(lx, -INF, sizeof(lx));
    memset(ly, 0, sizeof(ly));
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            lx[i] = max(lx[i], w[i][j]);
        }
    }
}

bool dfs(int u) {
    visx[u] = 1;
    for (int v = 1; v <= m; v++) {
        if (!visy[v]) {
            int tmp = lx[u] + ly[v] - w[u][v];
            if (tmp == 0) {
                visy[v] = 1;
                if (link[v] == -1 || dfs(link[v])) {
                    link[v] = u;
                    return true;
                }
            } else {
                slack[v] = min(slack[v], tmp);
            }
        }
    }
    return false;
}

void KM() {
    for (int i = 1; i <= n; i++) {
        memset(slack, INF, sizeof(slack));
        while (true) {
            memset(visx, 0, sizeof(visx));
            memset(visy, 0, sizeof(visy));
            if (dfs(i)) break;
            int d = INF;
            for (int j = 1; j <= m; j++) {
                if (!visy[j]) d = min(d, slack[j]);
            }
            for (int j = 1; j <= n; j++) {
                if (visx[j]) lx[j] -= d;
            }
            for (int j = 1; j <= m; j++) {
                if (visy[j]) ly[j] += d;
                else slack[j] -= d;
            }
        }
    }
    for (int i = 0; i < m; i++) {
        if (link[i] != -1) ans = min(ans, lx[link[i]] + ly[i]);
    }
}

void dfs(int u, int cnt, int sum) {
    if (cnt >= ans) return;
    if (u == n + 1) {
        ans = cnt;
        return;
    }
    priority_queue<Node> pq;
    for (int i = 1; i <= m; i++) {
        if (lx[u] + ly[i] == w[u][i]) {
            pq.push({u, i, w[u][i]});
        }
    }
    while (!pq.empty()) {
        int u = pq.top().u, v = pq.top().v, w = pq.top().w;
        pq.pop();
        if (visx[u] || visy[v]) continue;
        visx[u] = visy[v] = 1;
        link[v] = u;
        dfs(u + 1, cnt + 1, sum + w);
        link[v] = -1;
        visx[u] = visy[v] = 0;
    }
    dfs(u + 1, cnt, sum);
}

int main() {
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            cin >> w[i][j];
        }
    }
    init();
    KM();
    memset(visx, 0, sizeof(visx));
    memset(visy, 0, sizeof(visy));
    dfs(1, 0, 0);
    cout << ans << endl;
    return 0;
}

其中，`w[i][j]`表示第i个点和第j条边之间的权值，`lx[i]`表示第i个点的顶标，`ly[j]`表示第j条边的顶标，`link[j]`表示第j条边匹配的点，`visx[i]`表示第i个点是否被访问过，`visy[j]`表示第j条边是否被访问过。`KM()`函数为求解最大权匹配的函数，`dfs()`函数为分支限界法的递归函数。