dnomd343
/
klotski
mirror of https://github.com/dnomd343/klotski.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

perf: algorithm of all_cases

legacy
Dnomd343 2 years ago
parent
bdd6260866
commit
14bfb10533
2 changed files with 65 additions and 175 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. BIN
      all_cases/all
  2. 240
      all_cases/main.cc

BIN
all_cases/all
View File

Binary file not shown.

240
all_cases/main.cc
View File

@ -1,9 +1,6 @@
#include <iostream>
#include <vector>
#include <algorithm>
void load_basic_ranges(std::vector<uint32_t> &basic_ranges);
void build_basic_ranges(int n1, int n2, int n3, int n4, std::vector<uint32_t> &ranges);
#include <vector>
inline uint32_t binary_count(uint32_t bin) { // get number of non-zero bits
bin -= (bin >> 1) & 0x55555555;
@ -15,7 +12,7 @@ inline uint32_t binary_count(uint32_t bin) { // get number of non-zero bits
return bin & 0b111111;
}
uint32_t binary_reverse(uint32_t &bin) { // reverse binary every 2-bits
inline uint32_t binary_reverse(uint32_t bin) { // reverse binary every 2-bits
bin = ((bin << 16) & 0xFFFF0000) | ((bin >> 16) & 0x0000FFFF);
bin = ((bin << 8) & 0xFF00FF00) | ((bin >> 8) & 0x00FF00FF);
bin = ((bin << 4) & 0xF0F0F0F0) | ((bin >> 4) & 0x0F0F0F0F);
@ -23,9 +20,9 @@ uint32_t binary_reverse(uint32_t &bin) { // reverse binary every 2-bits
}
bool check_case(uint32_t head, uint32_t range) { // check whether the case is valid
uint32_t status = 0b110011 << head; // fill 2x2 block
uint32_t mask = 0b110011 << head; // fill 2x2 block
for (int addr = 0; range; range >>= 2) { // traverse every 2-bits
while (status >> addr & 0b1) {
while (mask >> addr & 0b1) {
++addr; // search next not filled block
}
switch (range & 0b11) {
@ -34,235 +31,128 @@ bool check_case(uint32_t head, uint32_t range) { // check whether the case is va
if (addr > 19) { // invalid address
return false;
}
status |= 0b1 << addr; // fill 1x1 block
mask |= 0b1 << addr; // fill 1x1 block
break;
case 0b10: // 2x1 block
if (addr > 15 || status >> (addr + 4) & 0b1) { // invalid address
if (addr > 15 || mask >> (addr + 4) & 0b1) { // invalid address
return false;
}
status |= 0b10001 << addr; // fill 2x1 block
mask |= 0b10001 << addr; // fill 2x1 block
break;
case 0b01: // 1x2 block
if (addr > 18 || (addr & 0b11) == 0b11 || status >> (addr + 1) & 0b1) { // invalid address
if (addr > 18 || (addr & 0b11) == 0b11 || mask >> (addr + 1) & 0b1) { // invalid address
return false;
}
status |= 0b11 << addr; // fill 1x2 block
mask |= 0b11 << addr; // fill 1x2 block
break;
}
}
return true;
}
void find_all_cases(std::vector<uint64_t> &all_cases) {
std::vector<uint32_t> basic_ranges, basic_rev_ranges;
load_basic_ranges(basic_ranges);
for (uint32_t range : basic_ranges) {
basic_rev_ranges.emplace_back(binary_reverse(range));
}
all_cases.clear();
for (uint32_t head = 0; head < 16; ++head) { // address for 2x2 block
if ((head & 0b11) == 0b11) { // aka (head % 4 == 3)
continue;
}
uint64_t prefix = int64_t(head) << 32;
for (uint32_t range : basic_rev_ranges) { // combine 2x2 address and range
if (check_case(head, range)) {
// TODO: emplace with range_rev
all_cases.emplace_back(prefix | range);
}
}
}
}
void load_basic_ranges(std::vector<uint32_t> &basic_ranges) { // load basic ranges
basic_ranges.clear();
for (int n = 0; n <= 7; ++n) { // number of 1x2 and 2x1 block -> 0 ~ 7
for (int n_2x1 = 0; n_2x1 <= n; ++n_2x1) { // number of 2x1 block -> 0 ~ n
for (int n_1x1 = 0; n_1x1 <= (14 - n * 2); ++n_1x1) { // number of 1x1 block -> 0 ~ (14 - 2n)
int n_1x2 = n - n_2x1;
int n_space = 16 - n * 2 - n_1x1;
// 0x0 -> 00 / 1x2 -> 01 / 2x1 -> 10 / 1x1 -> 11
build_basic_ranges(n_space, n_1x2, n_2x1, n_1x1, basic_ranges);
}
}
}
std::sort(basic_ranges.begin(), basic_ranges.end()); // sort basic ranges
return true; // case valid
}
void build_basic_ranges(int n1, int n2, int n3, int n4, std::vector<uint32_t> &ranges) {
// printf("generate n1 = %d | n2 = %d | n3 = %d | n4 = %d\n", n1, n2, n3, n4);
void build_basic_ranges(int n1, int n2, int n3, int n4, std::vector<uint32_t> &ranges) { // build target ranges
int len, limit;
constexpr uint32_t M_01 = 0b01 << 30;
constexpr uint32_t M_10 = 0b10 << 30;
constexpr uint32_t M_11 = 0b11 << 30;
std::vector<uint32_t> cache_1;
std::vector<uint32_t> cache_2;
int len, limit;
std::vector<uint32_t> cache_1, cache_2;
len = n1 + n2;
limit = 0b1 << len;
for (uint32_t bin = 0; bin < limit; ++bin) {
if (binary_count(bin) != n2) { // skip binary without `n2` non-zero bits
continue;
}
uint32_t range = 0;
uint32_t mask = bin;
for (int i = 0; i < len; ++i) { // generate range base on binary value
range >>= 2;
if (mask & 0b1) { // non-zero bit
range |= M_01;
if ((bin >> i) & 0b1) { // non-zero bit
(range >>= 2) |= M_01;
}
mask >>= 1;
}
cache_1.emplace_back(range); // insert into cache level 1
cache_1.emplace_back(range); // insert into first layer
}
len += n3;
limit <<= n3;
for (uint32_t bin = 0; bin < limit; ++bin) {
if (binary_count(bin) != n3) { // skip binary without `n3` non-zero bits
continue;
}
for (uint32_t base : cache_1) { // traverse cache level 1
for (uint32_t base : cache_1) { // traverse first layer
uint32_t range = 0;
uint32_t mask = bin;
for (int i = 0; i < len; ++i) { // generate range base on binary value
range >>= 2;
if (mask & 0b1) { // non-zero bit
range |= M_10;
} else { // zero bit
range |= base & M_11;
base <<= 2;
if ((bin >> i) & 0b1) { // non-zero bit
(range >>= 2) |= M_10;
continue;
}
mask >>= 1;
(range >>= 2) |= base & M_11;
base <<= 2;
}
cache_2.emplace_back(range); // insert into cache level 2
cache_2.emplace_back(range); // insert into second layer
}
}
len += n4;
limit <<= n4;
for (uint32_t bin = 0; bin < limit; ++bin) {
if (binary_count(bin) != n4) { // skip binary without `n4` non-zero bits
continue;
}
for (uint32_t base : cache_2) { // traverse cache level 2
for (uint32_t base : cache_2) { // traverse second layer
uint32_t range = 0;
uint32_t mask = bin;
for (int i = 0; i < len; ++i) { // generate range base on binary value
range >>= 2;
if (mask & 0b1) { // non-zero bit
range |= M_11;
} else { // zero bit
range |= base & M_11;
base <<= 2;
if ((bin >> i) & 0b1) { // non-zero bit
(range >>= 2) |= M_11;
continue;
}
mask >>= 1;
(range >>= 2) |= base & M_11;
base <<= 2;
}
ranges.emplace_back(range); // insert into release ranges
}
}
}
//bool check_case(uint32_t head, uint32_t range) { // whether case is valid
//
// constexpr uint32_t M_00 = 0B00 << 30;
// constexpr uint32_t M_01 = 0b01 << 30;
// constexpr uint32_t M_10 = 0b10 << 30;
// constexpr uint32_t M_11 = 0b11 << 30;
//
// uint32_t status = 0b110011 << head;
//
// for (int addr = 0; range; range <<= 2) {
// while (status >> addr & 0x1) {
// ++addr;
// }
//
// switch (range & M_11) {
// case M_00: // space
// case M_11: // 1x1
// if (addr > 19) {
// return false;
// }
// status |= 0b1 << addr;
// break;
// case M_01: // 1x2
// if (addr > 18 || (addr & 0b11) == 0b11 || status >> (addr + 1) & 0b1) {
// return false;
// }
// status |= 0b11 << addr;
// break;
// case M_10: // 2x1
// if (addr > 15 || status >> (addr + 4) & 0b1) {
// return false;
// }
// status |= 0b10001 << addr;
// break;
// }
// }
//
// return true;
// uint32_t status = 0x110011 << head;
// for (int addr = 0; range; range >>= 2) {
// while (status >> addr & 0x1) {
// ++addr;
// }
// switch (range & 0x3) {
// case 0b00: // space
// case 0b11: // 1x1
// if (addr > 19) {
// return false;
// }
// status |= 0b1 << addr;
// break;
// case 0b01: // 1x2
// if (addr > 18 || addr % 4 == 3 || status >> (addr + 1) & 0x1) {
// return false;
// }
// status |= 0b11 << addr;
// break;
// case 0b10: // 2x1
// if (addr > 15 || status >> (addr + 4) & 0x1) {
// return false;
// }
// status |= 0b10001 << addr;
// break;
// }
// }
// return true;
void load_basic_ranges(std::vector<uint32_t> &basic_ranges) { // load basic ranges
basic_ranges.clear();
for (int n = 0; n <= 7; ++n) { // number of 1x2 and 2x1 block -> 0 ~ 7
for (int n_2x1 = 0; n_2x1 <= n; ++n_2x1) { // number of 2x1 block -> 0 ~ n
for (int n_1x1 = 0; n_1x1 <= (14 - n * 2); ++n_1x1) { // number of 1x1 block -> 0 ~ (14 - 2n)
int n_1x2 = n - n_2x1;
int n_space = 16 - n * 2 - n_1x1;
// 0x0 -> 00 / 1x2 -> 01 / 2x1 -> 10 / 1x1 -> 11
build_basic_ranges(n_space, n_1x2, n_2x1, n_1x1, basic_ranges); // build target ranges
}
}
}
std::sort(basic_ranges.begin(), basic_ranges.end()); // sort basic ranges
for (uint32_t &range : basic_ranges) {
range = binary_reverse(range); // range reverse
}
}
//}
void find_all_cases(std::vector<uint64_t> &all_cases) { // find all valid cases
std::vector<uint32_t> basic_ranges;
load_basic_ranges(basic_ranges); // load basic ranges
all_cases.clear();
for (uint32_t head = 0; head < 16; ++head) { // address for 2x2 block
if ((head & 0b11) == 0b11) { // aka (head % 4 == 3)
continue;
}
uint64_t prefix = int64_t(head) << 32;
for (uint32_t range : basic_ranges) { // combine 2x2 address and range
if (check_case(head, range)) {
all_cases.emplace_back(prefix | binary_reverse(range)); // found valid case
}
}
}
}
int main() {
// std::vector<uint32_t> temp;
// load_basic_ranges(temp);
// n1 = 2 | n2 = 1 | n3 = 3 | n4 = 6
// build_basic_ranges(2, 1, 3, 6, temp);
std::vector<uint64_t> temp;
find_all_cases(temp);
printf("size -> %ld\n", temp.size());
std::vector<uint64_t> all_cases;
find_all_cases(all_cases);
printf("size -> %ld\n", all_cases.size());
return 0;
}

Write Preview
Loading…
Cancel
Save