Битовые маски

Как известно, числа в памяти компьютера представляются в двоичной системе счисления в виде последовательности битов. Один бит может иметь значение или . Можно провести аналогию между битами и значениями типа bool: обозначает false, а - true. По такой аналогии число (последовательность битов) можно представить как массив значений bool. Например, тип int может обозначать массив из значений bool, а long long - из .

Чаще всего массивы bool небольшого размера испольуются для обозначения некоторого подмножества объектов, выбранного из множества. Например, для обозначения элементов с индексами и (0-индексация), выбранных из множества из пяти элементов используется массив , или . Его можно представить в виде значения типа int: (индексация обычно начинается с младших битов числа, записываемых справа).

При интерпретации такого значения как обычного числа, оно будет равно . Но при интерпретации его как массива логических значений (битов), оно будет обозначать . С точки зрения C++ эти два значения равносильны, и то, является ли значение типа int числом, или массивом bool, зависит только от контекста, в котором оно используется.

При использовании значений типа int или long long как массивов из bool, такие значения называются битовыми масками.

Операции с битовыми масками

Для работы с масками используются побитовые операции , и битовые сдвиги.

Пусть две маски обозначают два множества элементов, и нам нужно получить маску, содержащую элементы, входящие в оба множества (пересечение множеств). В новой маске true должны находится только в тех позициях, где в обеих масках находились true. Несложно заметить, что такое описание соответствует побитовой операции :

Битовое И

int c = a & b; // маска c равна пересечению масок a и b

Другой распространённой операцией является объединение множеств. При объединении в новой маске true должны находиться в тех позициях, в которых в хотя бы одной из масок находилось true. Такое описание соответствует побитовой операции :

Битовое ИЛИ

int c = a | b; // маска c равна объединению масок a и b

Для получения значения индивидуального бита используется комбинация битового сдвига вправо и операции . Сначала нам нужно сдвинуть биты маски так, чтобы нужный бит оказался самым младшим (находился справа). Затем нам нужно откинуть все остальные биты маски. Реализуется это следующим образом:

Получение значения бита

int bit = (a >> idx) & 1; // bit равен значению idx-го бита в маске a

Для установки значения определённого бита маски в true мы должны применить к нему операцию . Реализуется это так (ко всем остальным битам применяется , не имеющая никакого эффекта):

Установка значения бита

int b = a | (1 << idx); // маска b - копия маски a, в которой idx-ый бит установлен в true

Для изменения значения определённого бита на противоположное, нужно применить к нему операцию . Ко всем остальным битам применяется , также не имеющая никакого эффекта:

Установка значения бита на обратное

int b = a ^ (1 << idx); // маска b - копия маски a с противоположным значением idx-го бита

Это самые распространённые операции, выполняемые с масками. Существует множество других, здесь не приведённых, но все они основаны на , и сдвигах.

Динамическое программирование по подмножествам

Битовые маски часто используются как параметры для динамического программирования. Такой вид ДП называется ДП по маскам, или ДП по подмножествам.

Классической задачей на ДП по подмножествам является широко известная задача о коммивояжёре (англ. TSP - Travelling Salesman Problem). В общем виде она ставится следующим образом:

Существует городов, между некоторыми из которых есть дороги. Требуется обойти все города, вернувшись в первый, так, чтобы длина пути была минимальной.

Эта задача является классической NP-полной задачей, и ДП по подмножествам со сложностью порядка - её оптимальное решение.

Для простоты реализации примем, что города являются точками на геометрической плоскости, и между каждой парой есть путь, длина которого равна расстоянию между точками.

Обозначим за - длину кратчайшего пути, начинающегося в вершине , проходящего через все вершины , и заканчивающегося в вершине (). Начальные значения ДП можно записать следующим образом:

Запись обозначает маску, обозначающую множество, состоящее только из элемента .

Формула перехода для ДП выглядит так:

Запись обозначает множество без элемента .

Формула перехода обозначает следующее: чтобы попасть в вершину , нужно перейти в неё из какой-либо другой вершины , также входящей в . Из всех таких вершин нужно выбрать такую, что общая длина пути в будет наименьшей. Общая длина пути рассчитывается как длина пути в () плюс длина пути из в ().

Чтобы найти минимальную длину цикла из всех вершин, нужно перебрать вершину , и выбрать такую, что длина цикла минимальна. Длина такого цикла вычисляется по формуле :

Запись обозначает множество всех вершин.

Может показаться, что порядок пересчёта такого ДП будет достаточно сложным. На самом деле это не так: заметьте что для пересчета нам нужно, чтобы уже был посчитан ответ для маски . Можно легко доказать, что в численном выражении будет гарантированно меньше , так как на некоторой позиции в будет находиться бит , а в бит . Значит, можно просто пересчитывать ДП в порядке возрастания значения в численном выражении.

Реализация решения задачи о коммивояжёре

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#include <bits/stdc++.h>

using namespace std;

const double INF = 1e9 + 7;     //бесконечность

double x[20], y[20];    //координаты городов.

//Заметим, что для N элементов существует 2^N возможных подмножеств (масок)
//значением от 0 до 2^N - 1.
//Можно просто возвести 2 в произвольную степень с помощью битового сдвига:
//2^N = 1 << N
double dp[1 << 20][20];

//Расстояние между городами a и b
double dst(int a, int b) {
    double dx = x[a] - x[b], dy = y[a] - y[b];
    return sqrt(dx * dx + dy * dy);
}

int main() {
    int n;
    cin >> n;

    for (int i = 0; i < n; i++) {
        cin >> x[i] >> y[i];
    }

    for (int mask = 0; mask < (1 << n); mask++) {
        for (int i = 0; i < n; i++) {
            dp[mask][i] = INF;
        }
    }

    dp[1][0] = 0;   //Маска 1 содержит только нулевой элемент.

    for (int mask = 2; mask < (1 << n); mask++) {
        for (int i = 0; i < n; i++) {
            if ((mask >> i) & 1) {      //Если mask содержит i
                int mask_without_i = mask ^ (1 << i);

                for (int j = 0; j < n; j++) {
                    if (j != i && ((mask >> j) & 1)) {  //Если j != i и mask содержит j
                        dp[mask][i] = min(dp[mask][i], dp[mask_without_i][j] + dst(j, i));
                    }
                }
            }
        }
    }

    double ans = INF;
    int mask_all = (1 << n) - 1;  //маска, содержащая все элементы

    for (int i = 0; i < n; i++) {
        ans = min(ans, dp[mask_all][i] + dst(i, 0));
    }

    cout << ans << endl;
}