《Steam 游戏平台:开发与商业化》6.2 预算分配与优化

6.1 算完单渠道 ROI,本节处理钱在渠道之间怎么分:每个渠道的边际收益随投入递减,平均分往往不是最优。本节用贪心分配模型把预算逐档投给当前边际收益最高的渠道,lab 复现各渠道档数、总归因收入与混合 ROI,对比「按 ROI 排序再分配」和「平均分配」的差距。

6.2 预算分配与优化

6.1 算出每个渠道的 ROI,本节回答钱在渠道之间怎么分。最容易犯的错是「按单渠道 ROI 排序,把预算全给 ROI 最高的渠道」——因为渠道的边际收益会递减:同一渠道投入越多,后续每一档的回报越低。新品节第一档 3 倍回报,投到第五档可能只剩 0.6 倍。因此正确做法不是「选一个渠道」,而是逐档比较所有渠道的下一档边际收益,每次把下一块钱投给边际收益最高者。

这也解释了 6.1 的遗留问题:投放渠道整体 ROI 只有 25%,为什么还值得投?因为 KOL 的高回报档投满之后,投放的第一档边际收益可能已经高于 KOL 的下一档。预算分配是「边际」的比较,不是「平均」的比较。

本章与站内既有内容的分工

  • 6.1 给出各渠道的 ROI 与归因口径;本节把 ROI 变成「边际收益表」,做跨渠道的再分配。
  • 1.3 立了营销预算的总盘子(如总预算 10 万美元中营销 25%);本节处理盘子内部怎么分,输出是「各渠道各分几档钱」。
  • game/publish/steam/ 的 Steam游戏营销与社区增长高级策略.md 讲渠道操作与归因;本节不写投放操作,写「预算在渠道间怎么调拨」的模型。
  • 8.3 的仪表盘会在投放后回看实际边际收益,校准本节用的边际表。

边际收益表与贪心分配

给三个渠道各一张边际收益表(模型假设,每档成本固定):

渠道每档成本边际收益倍率(逐档)
新品节内容1,000 美元3.0 → 2.2 → 1.5 → 1.0 → 0.6
KOL2,000 美元2.5 → 1.8 → 1.0 → 0.4
投放3,000 美元1.8 → 1.2 → 0.6

边际收益金额 = 档成本 × 倍率。贪心分配把总预算逐档投给「当前边际收益金额最高」的渠道:

步骤剩余预算候选(新品节/KOL/投放)选择说明
112,0003,000 / 5,000 / 5,400投放第 1 档边际收益金额最高
29,0003,000 / 5,000 / 3,600KOL 第 1 档
37,0003,000 / 3,600 / 3,600KOL 第 2 档与投放并列时选倍率高的
45,0003,000 / 2,000 / 3,600投放第 2 档
52,0003,000 / 2,000 / —新品节第 1 档投放第 3 档 3,000 超出剩余
61,0002,200 / — / —新品节第 2 档剩余只够新品节

结果:新品节 2 档(投入 2,000)、KOL 2 档(4,000)、投放 2 档(6,000),总投入 12,000,总归因收入 22,800,混合 ROI 90%。

关键读数:

  1. 投放拿到的预算不是因为它平均 ROI 高,而是因为它的第一档边际收益高。KOL 第一档 5,000 更高,所以先投 KOL;投放第二档 3,600 又高于 KOL 第三档,所以回来投投放。
  2. 新品节这样的免费/低成本渠道仍要占用预算档:它每档成本低,边际收益金额未必低。预算 6,000 时三渠道各 1 档,收入 13,400,ROI 123%——预算收紧时每个渠道都留第一档。
  3. 超额预算会把边际档吃满:预算 30,000 时新品节 5 档、KOL 4 档、投放 3 档全部投满,投入 22,000、收入 30,500——超过这个额度再投任何渠道都是负边际,预算应当停止加码。

决策表

场景判定行动
渠道某档边际收益 < 1.0该档会亏停在该档之前,预算转向其他渠道
预算收紧只够部分渠道第一档每渠道留第一档,砍后续低边际档
预算充裕边际档全部投满不再加码,多余预算回储备金(见 1.3)
投放后实际边际 < 表值模型参数偏差回 8.3 校准边际表,下周期重分配

模型参数与数据口径

  • 每档成本与边际收益倍率:模型假设,非官方数值。真实边际只能从投放后回看(8.3 仪表盘)逐步校准。
  • 贪心分配本身是通用算法,不依赖任何官方数字;「逐档比较边际收益」是可复算的决策逻辑。
  • 金额用整数美分,混合 ROI 与 6.1 口径一致。

可运行产物:C++ 最小验证

下面的仿真把预算分配固化成可执行的计算:三渠道边际收益表、贪心分配各档数、总归因收入与混合 ROI,以及零预算/超额预算的边界。它与 src/steam-launch-06-2-budget-allocation-optimization.cpp 逐字节一致:

// file: src/steam-launch-06-2-budget-allocation-optimization.cpp
// tier: L1
// verify: clang++ -std=c++20 -Wall -I. src/steam-launch-06-2-budget-allocation-optimization.cpp -o bin/steam-launch-06-2-budget-allocation-optimization && ./bin/steam-launch-06-2-budget-allocation-optimization
//
// mock:复现营销预算分配优化——各渠道有递减的边际收益表,用贪心
// 每次把下一笔钱投入边际收益最高的渠道,输出各渠道档数与混合 ROI。
// 边际倍率属模型假设,非官方数值;金额用整数美分。
#include "verify.h"

#include <cstdint>
#include <string>
#include <vector>

namespace steam_repro {

// 预算分配优化模型:渠道边际收益表 + 贪心分配。
class MockBudgetOptimizer {
 public:
  struct Channel {
    std::string name;
    int64_t stepCostCents;       // 每档成本
    std::vector<int> marginPct;  // 每档边际收益倍率 ×100(300 = 3.0x)
  };

  struct Alloc {
    std::string name;
    int steps;
    int64_t spendCents;
    int64_t revenueCents;
  };

  void load(const std::vector<Channel>& cs) { channels_ = cs; }

  // 贪心分配:剩余预算内选「边际收益金额」最高的下一档;
  // 并列时选边际倍率高者,再并列选成本低者。
  std::vector<Alloc> allocate(int64_t budgetCents) const {
    std::vector<Alloc> out;
    std::vector<int> used(channels_.size(), 0);
    std::vector<int64_t> rev(channels_.size(), 0);
    int64_t remain = budgetCents;
    while (true) {
      int best = -1;
      int64_t bestRev = -1;
      int bestMargin = -1;
      int64_t bestCost = 0;
      for (size_t i = 0; i < channels_.size(); ++i) {
        if (used[i] >= static_cast<int>(channels_[i].marginPct.size())) continue;
        int64_t cost = channels_[i].stepCostCents;
        if (cost > remain) continue;
        int64_t r = cost * channels_[i].marginPct[used[i]] / 100;
        int mg = channels_[i].marginPct[used[i]];
        if (r > bestRev || (r == bestRev && mg > bestMargin) ||
            (r == bestRev && mg == bestMargin && cost < bestCost)) {
          best = static_cast<int>(i);
          bestRev = r;
          bestMargin = mg;
          bestCost = cost;
        }
      }
      if (best < 0) break;
      used[best]++;
      rev[best] += bestRev;
      remain -= channels_[best].stepCostCents;
    }
    for (size_t i = 0; i < channels_.size(); ++i) {
      if (used[i] == 0) continue;
      out.push_back({channels_[i].name, used[i],
                     channels_[i].stepCostCents * used[i], rev[i]});
    }
    return out;
  }

  // 合并口径
  int64_t totalSpendCents(const std::vector<Alloc>& a) const {
    int64_t s = 0;
    for (const auto& x : a) s += x.spendCents;
    return s;
  }

  int64_t totalRevenueCents(const std::vector<Alloc>& a) const {
    int64_t r = 0;
    for (const auto& x : a) r += x.revenueCents;
    return r;
  }

  int64_t roiPercent(const std::vector<Alloc>& a) const {
    int64_t sp = totalSpendCents(a);
    if (sp <= 0) return -1;
    return (totalRevenueCents(a) - sp) * 100 / sp;
  }

  // 按名称取某渠道的档数
  int stepsOf(const std::vector<Alloc>& a, const std::string& name) const {
    for (const auto& x : a)
      if (x.name == name) return x.steps;
    return 0;
  }

 private:
  std::vector<Channel> channels_;
};

}  // namespace steam_repro

int main() {
  using namespace steam_repro;
  MockBudgetOptimizer o;
  // 三渠道边际收益表(模型假设):新品节每档 $1,000,KOL $2,000,投放 $3,000
  o.load({
      {"nextfest", 100000, {300, 220, 150, 100, 60}},
      {"kol", 200000, {250, 180, 100, 40}},
      {"ads", 300000, {180, 120, 60}},
  });

  // 1-3. 总预算 $12,000:贪心把三渠道各推到第 2 档
  auto a12 = o.allocate(1200000);
  CHECK(o.stepsOf(a12, "nextfest") == 2);
  CHECK(o.stepsOf(a12, "kol") == 2);
  CHECK(o.stepsOf(a12, "ads") == 2);

  // 4-6. 支出耗尽预算;归因收入 $22,800;混合 ROI 90%
  CHECK(o.totalSpendCents(a12) == 1200000);
  CHECK(o.totalRevenueCents(a12) == 2280000);
  CHECK(o.roiPercent(a12) == 90);

  // 7-9. 预算减半($6,000):三渠道各 1 档,收入 $13,400,ROI 123%
  auto a6 = o.allocate(600000);
  CHECK(o.stepsOf(a6, "nextfest") == 1);
  CHECK(o.stepsOf(a6, "kol") == 1);
  CHECK(o.stepsOf(a6, "ads") == 1);
  CHECK(o.totalRevenueCents(a6) == 1340000);
  CHECK(o.roiPercent(a6) == 123);

  // 10-11. 零预算:无分配,ROI 未定义
  auto a0 = o.allocate(0);
  CHECK(a0.empty());
  CHECK(o.roiPercent(a0) == -1);

  // 12-14. 超额预算:所有边际档吃满,支出 $22,000,收入 $30,500
  auto afull = o.allocate(3000000);
  CHECK(o.stepsOf(afull, "nextfest") == 5);
  CHECK(o.stepsOf(afull, "kol") == 4);
  CHECK(o.stepsOf(afull, "ads") == 3);
  CHECK(o.totalRevenueCents(afull) == 3050000);
  CHECK(o.totalSpendCents(afull) == 2200000);

  return lab::report("06-2 预算分配与优化");
}

本机实测(Apple clang 16,clang++ -std=c++20 -Wall):编译通过(零警告),断言 18/18 通过。

小结

  • 渠道预算分配是「边际」比较不是「平均」比较:每次把下一档投给边际收益最高者。
  • 贪心分配输出各渠道档数、总归因收入与混合 ROI,给 6.1 的渠道表补上「怎么分」。
  • 预算收紧时每个渠道留第一档;超额预算吃满边际档后停止加码。
  • 边际收益表是模型假设,投放后按 8.3 的实际数据校准。

阅读导航:上一节:6.1 渠道 ROI 模型 · 下一节:6.3 KOL 与内容营销决策 。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图