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

perf: AllCases module

legacy
Dnomd343 2 years ago
parent
614ad48f7f
commit
c67730aa25
2 changed files with 193 additions and 193 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. 274
      all_cases/all_cases.cc
  2. 112
      klotski/all_cases.cc

274
all_cases/all_cases.cc
View File

@ -1,145 +1,145 @@
#include <algorithm>
#include "all_cases.h"
inline uint32_t binary_count(uint32_t bin) { // get number of non-zero bits
bin -= (bin >> 1) & 0x55555555;
bin = (bin & 0x33333333) + ((bin >> 2) & 0x33333333);
bin = ((bin >> 4) + bin) & 0x0F0F0F0F;
// return (bin * 0x01010101) >> 24; // AMD CPU
bin += bin >> 8;
bin += bin >> 16;
return bin & 0b111111;
}
//inline uint32_t binary_count(uint32_t bin) { // get number of non-zero bits
// bin -= (bin >> 1) & 0x55555555;
// bin = (bin & 0x33333333) + ((bin >> 2) & 0x33333333);
// bin = ((bin >> 4) + bin) & 0x0F0F0F0F;
//// return (bin * 0x01010101) >> 24; // AMD CPU
// bin += bin >> 8;
// bin += bin >> 16;
// return bin & 0b111111;
//}
uint32_t AllCases::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);
return ((bin << 2) & 0xCCCCCCCC) | ((bin >> 2) & 0x33333333);
}
//uint32_t AllCases::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);
// return ((bin << 2) & 0xCCCCCCCC) | ((bin >> 2) & 0x33333333);
//}
bool AllCases::check_case(uint32_t head, uint32_t range) { // check whether the case is valid
uint32_t mask = 0b110011 << head; // fill 2x2 block
for (int addr = 0; range; range >>= 2) { // traverse every 2-bits
while (mask >> addr & 0b1) {
++addr; // search next not filled block
}
switch (range & 0b11) {
case 0b00: // space block
case 0b11: // 1x1 block
if (addr > 19) { // invalid address
return false;
}
mask |= 0b1 << addr; // fill 1x1 block
break;
case 0b10: // 2x1 block
if (addr > 15 || mask >> (addr + 4) & 0b1) { // invalid address
return false;
}
mask |= 0b10001 << addr; // fill 2x1 block
break;
case 0b01: // 1x2 block
if (addr > 18 || (addr & 0b11) == 0b11 || mask >> (addr + 1) & 0b1) { // invalid address
return false;
}
mask |= 0b11 << addr; // fill 1x2 block
break;
}
}
return true; // valid case
}
//bool AllCases::check_case(uint32_t head, uint32_t range) { // check whether the case is valid
// uint32_t mask = 0b110011 << head; // fill 2x2 block
// for (int addr = 0; range; range >>= 2) { // traverse every 2-bits
// while (mask >> addr & 0b1) {
// ++addr; // search next not filled block
// }
// switch (range & 0b11) {
// case 0b00: // space block
// case 0b11: // 1x1 block
// if (addr > 19) { // invalid address
// return false;
// }
// mask |= 0b1 << addr; // fill 1x1 block
// break;
// case 0b10: // 2x1 block
// if (addr > 15 || mask >> (addr + 4) & 0b1) { // invalid address
// return false;
// }
// mask |= 0b10001 << addr; // fill 2x1 block
// break;
// case 0b01: // 1x2 block
// if (addr > 18 || (addr & 0b11) == 0b11 || mask >> (addr + 1) & 0b1) { // invalid address
// return false;
// }
// mask |= 0b11 << addr; // fill 1x2 block
// break;
// }
// }
// return true; // valid case
//}
void AllCases::generate_ranges(int n1, int n2, int n3, int n4) { // 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, cache_2;
//void AllCases::generate_ranges(int n1, int n2, int n3, int n4) { // 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, 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;
// for (int i = 0; i < len; ++i) { // generate range base on binary value
// range >>= 2;
// if ((bin >> i) & 0b1) { // non-zero bit
// range |= M_01; // 01000...
// }
// }
// 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 first layer
// uint32_t range = 0;
// for (int i = 0; i < len; ++i) { // generate range base on binary value
// if ((bin >> i) & 0b1) { // non-zero bit
// (range >>= 2) |= M_10; // 10000...
// continue;
// }
// (range >>= 2) |= base & M_11;
// base <<= 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 second layer
// uint32_t range = 0;
// for (int i = 0; i < len; ++i) { // generate range base on binary value
// if ((bin >> i) & 0b1) { // non-zero bit
// (range >>= 2) |= M_11; // 11000...
// continue;
// }
// (range >>= 2) |= base & M_11;
// base <<= 2;
// }
// basic_ranges.emplace_back(range); // insert into release ranges
// }
// }
//}
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;
for (int i = 0; i < len; ++i) { // generate range base on binary value
range >>= 2;
if ((bin >> i) & 0b1) { // non-zero bit
range |= M_01; // 01000...
}
}
cache_1.emplace_back(range); // insert into first layer
}
//void AllCases::load_basic_ranges() { // load basic ranges
// 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
// generate_ranges(n_space, n_1x2, n_2x1, n_1x1); // 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
// }
//}
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 first layer
uint32_t range = 0;
for (int i = 0; i < len; ++i) { // generate range base on binary value
if ((bin >> i) & 0b1) { // non-zero bit
(range >>= 2) |= M_10; // 10000...
continue;
}
(range >>= 2) |= base & M_11;
base <<= 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 second layer
uint32_t range = 0;
for (int i = 0; i < len; ++i) { // generate range base on binary value
if ((bin >> i) & 0b1) { // non-zero bit
(range >>= 2) |= M_11; // 11000...
continue;
}
(range >>= 2) |= base & M_11;
base <<= 2;
}
basic_ranges.emplace_back(range); // insert into release ranges
}
}
}
void AllCases::load_basic_ranges() { // load basic ranges
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
generate_ranges(n_space, n_1x2, n_2x1, n_1x1); // 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 AllCases::find_all_cases() { // find all valid cases
for (uint32_t head = 0; head < 16; ++head) { // address for 2x2 block
if ((head & 0b11) == 0b11) {
continue;
}
all_cases[head].clear();
for (uint32_t range : basic_ranges) { // combine 2x2 address and range
if (check_case(head, range)) {
all_cases[head].emplace_back(binary_reverse(range)); // found valid case
}
}
}
}
//void AllCases::find_all_cases() { // find all valid cases
// for (uint32_t head = 0; head < 16; ++head) { // address for 2x2 block
// if ((head & 0b11) == 0b11) {
// continue;
// }
// all_cases[head].clear();
// for (uint32_t range : basic_ranges) { // combine 2x2 address and range
// if (check_case(head, range)) {
// all_cases[head].emplace_back(binary_reverse(range)); // found valid case
// }
// }
// }
//}

112
klotski/all_cases.cc
View File

@ -2,6 +2,31 @@
#include "common.h"
#include "all_cases.h"
AllCases::AllCases(enum InitType init) {
switch (init) {
case InitType::WITH_ALL_CASES:
get_all_cases();
case InitType::WITH_BASIC_RANGES:
get_basic_ranges();
case WITH_NOTHING:
break;
}
}
const std::vector<uint32_t>* AllCases::get_basic_ranges() {
if (basic_ranges.empty()) {
build_basic_ranges(); // basic ranges initialize
}
return &basic_ranges;
}
const std::vector<uint32_t> (*AllCases::get_all_cases())[16] {
if (all_cases->empty()) {
find_all_cases(); // all cases initialize
}
return &all_cases;
}
inline uint32_t binary_count(uint32_t bin) { // get number of non-zero bits
bin -= (bin >> 1) & 0x55555555;
bin = (bin & 0x33333333) + ((bin >> 2) & 0x33333333);
@ -12,6 +37,37 @@ inline uint32_t binary_count(uint32_t bin) { // get number of non-zero bits
return bin & 0b111111;
}
void AllCases::find_all_cases() { // find all valid cases
get_basic_ranges(); // ensure basic ranges exist
for (uint32_t head = 0; head < 16; ++head) { // address of 2x2 block
if ((head & 0b11) == 0b11) {
continue; // invalid 2x2 address
}
for (uint32_t range : basic_ranges) { // check base on 2x2 address and range
if (Common::check_case(head, range)) {
all_cases[head].emplace_back(Common::range_reverse(range)); // found valid case
}
}
}
}
void AllCases::build_basic_ranges() { // build basic ranges
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
generate_ranges(n_space, n_1x2, n_2x1, n_1x1); // generate target ranges
}
}
}
std::sort(basic_ranges.begin(), basic_ranges.end()); // sort basic ranges
for (uint32_t &range : basic_ranges) {
range = Common::range_reverse(range); // range reverse
}
}
void AllCases::generate_ranges(int n1, int n2, int n3, int n4) { // generate target ranges
int len, limit;
constexpr uint32_t M_01 = 0b01 << 30;
@ -75,59 +131,3 @@ void AllCases::generate_ranges(int n1, int n2, int n3, int n4) { // generate tar
}
}
}
void AllCases::build_basic_ranges() { // build basic ranges
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
generate_ranges(n_space, n_1x2, n_2x1, n_1x1); // generate target ranges
}
}
}
std::sort(basic_ranges.begin(), basic_ranges.end()); // sort basic ranges
for (uint32_t &range : basic_ranges) {
range = Common::range_reverse(range); // range reverse
}
}
void AllCases::find_all_cases() { // find all valid cases
get_basic_ranges(); // ensure basic ranges exist
for (uint32_t head = 0; head < 16; ++head) { // address of 2x2 block
if ((head & 0b11) == 0b11) {
continue; // invalid 2x2 address
}
for (uint32_t range : basic_ranges) { // check base on 2x2 address and range
if (Common::check_case(head, range)) {
all_cases[head].emplace_back(Common::range_reverse(range)); // found valid case
}
}
}
}
AllCases::AllCases(enum InitType init) {
switch (init) {
case InitType::WITH_ALL_CASES:
get_all_cases();
case InitType::WITH_BASIC_RANGES:
get_basic_ranges();
case WITH_NOTHING:
break;
}
}
const std::vector<uint32_t>* AllCases::get_basic_ranges() {
if (basic_ranges.empty()) {
build_basic_ranges(); // basic ranges initialize
}
return &basic_ranges;
}
const std::vector<uint32_t> (*AllCases::get_all_cases())[16] {
if (all_cases->empty()) {
find_all_cases(); // all cases initialize
}
return &all_cases;
}

Write Preview
Loading…
Cancel
Save