Array2D CombinationWithDuplicatedElementsByNonRecursion(Array1D array, int K)
{
Array2D result;
if (array.empty() || K <= 0) { return result; }
if (array.size() < K) {
result.push_back(array); /** @warning maybe exclude it */
return result;
}
std::sort(array.begin(), array.end());
result.push_back(Array1D());
int last = array[0], opt_result_num = 1;
for (int i = 0; i < array.size(); i++) {
if (array[i] != last) {
last = array[i];
opt_result_num = result.size();
}
Array2D::size_type result_size = result.size();
for (int j = result_size - 1; j >= result_size - opt_result_num; j--) {
result.push_back(result[j]);
result.back().push_back(array[i]);
}
}
return result;
}
Array2D SetOfStacks(Array2D ope, int size)
{
// write code here
if (ope.empty()) { return Array2D(); }
if (size <= 0) { assert(false); }
/** @brief has no bugs, but too complex. */
// stack<Array1D> temp;
// Array1D cur_array(size);
// int cur_index = -1;
// for (int i = 0; i < ope.size(); i++) {
// if (ope[i][0] == 1) {
// if (cur_index == size - 1) {
// temp.push(cur_array);
// cur_array = Array1D(size);
// cur_index = -1;
// }
// cur_array[++cur_index] = ope[i][1];
// } else if (ope[i][0] == 2) {
// if (cur_index == -1) {
// if (temp.empty()) { return Array2D(); }
// cur_array = temp.top();
// temp.pop();
// cur_index = size - 1;
// }
// cur_index--;
// } else { return Array2D(); }
// }
//
// Array2D result(temp.size() + 1);
// if (cur_index > -1) {
// result[temp.size()] = Array1D(&cur_array[0], &cur_array[cur_index] + 1);
// }
// cur_index = temp.size() - 1;
// while(!temp.empty()) {
// result[cur_index--] = temp.top();
// temp.pop();
// }
/** @todo don't pass all test cases */
Array2D result;
Array1D cur_array;
for (Array2D::iterator it = ope.begin(); it != ope.end(); ++it) {
if ((*it)[0] == 1) {
if (cur_array.size() == size) {
result.push_back(cur_array);
cur_array.clear();
}
cur_array.push_back((*it)[1]);
} else if ((*it)[0] == 2){
if (cur_array.empty()) {
if (result.empty()) { assert(false); }
cur_array = result.front();
result.pop_back();
}
cur_array.pop_back();
} else { assert(false); }
}
if (!cur_array.empty()) { result.push_back(cur_array); }
return result;
}
static void CombinationWithDuplicatedElementsVer2Helper(Array1D &array, int left,
int k, int times,
Array1D &temp,
Array2D &result)
{
if (array.size() - left < k) { return; }
if (k == 0) {
result.push_back(temp);
return;
}
for (int i = left; i <= array.size(); i++) {
if (i == 0 || array[i] != array[i - 1]) {
times = 1;
temp.push_back(array[i]);
CombinationWithDuplicatedElementsVer2Helper(array, i + 1, k - 1, 1, temp, result);
temp.pop_back();
}
else {
times++;
if (temp.size() >= times - 1 && temp[temp.size() - times + 1] == array[i]) {
temp.push_back(array[i]);
CombinationWithDuplicatedElementsVer2Helper(array, i + 1, k - 1, times, temp, result);
temp.pop_back();
}
}
}
}
static void CombinationWithDuplicatedElementsHelper(Array1D &array, int left, int k,
int times, Array1D &temp, Array2D &result)
{
assert(left >= 0);
if (array.size() - left < k) { return; }
if (k == 0) {
result.push_back(temp);
return;
}
if (left == 0 || array[left] != array[left - 1]) {
temp.push_back(array[left]);
CombinationWithDuplicatedElementsHelper(array, left + 1, k - 1, 1, temp, result);
temp.pop_back();
CombinationWithDuplicatedElementsHelper(array, left + 1, k, 1, temp, result);
}
else {
if (temp.size() >= times && temp[temp.size() - times] == array[left]) {
temp.push_back(array[left]);
CombinationWithDuplicatedElementsHelper(array, left + 1, k - 1, times + 1, temp, result);
temp.pop_back();
}
CombinationWithDuplicatedElementsHelper(array, left + 1, k, times + 1, temp, result);
}
}
Array2D CombinationVer2(Array1D array, int K)
{
Array2D result;
if (array.empty() || K <= 0) { return result; }
if (array.size() < K) {
result.push_back(array); /** @warning maybe exclude it */
return result;
}
Array1D temp;
CombinationVer2Helper(array, 0, array.size() - 1, K, temp, result);
}
/**
* @brief find all permutation of array
* @brief array has some repeating elements
*/
Array2D PermutationUnique(Array1D array)
{
Array2D result;
if (array.empty()) { return result; }
if (array.size() == 1) {
result.push_back(array);
return result;
}
PermutationUniqueHelper(array, 0, result);
return result;
}
Array2D CombinationByDecrease(Array1D array, int K)
{
Array2D result;
if (array.empty() || K <= 0) { return result; }
if (array.size() < K) {
result.push_back(array); /** @warning maybe exclude it */
return result;
}
Array1D temp(K);
CombinationByDecreaseHelper(array, array.size(), K, temp, result);
}
Array2D CombinationWithDuplicatedElementsVer2(Array1D array, int K)
{
Array2D result;
if (array.empty() || K <= 0) { return result; }
if (array.size() < K) {
result.push_back(array); /** @warning maybe exclude it */
return result;
}
Array1D temp;
}
Array2D Combination(Array1D array, int K) {
Array2D result;
if (array.empty() || K <= 0) { return result; }
if (array.size() < K) {
result.push_back(array);
return result;
}
Array1D temp;
CombinationHelper(array, 0, array.size() - 1, K, temp, result);
return result;
}
static void PermutationHelper(Array1D &array, int index, Array2D &result)
{
if (index == array.size()) {
result.push_back(array);
return;
}
for (int i = index; i < array.size(); ++i) {
std::swap(array[index], array[i]);
PermutationHelper(array, index + 1, result);
std::swap(array[index], array[i]);
}
}
Array2D CombinationByNonRecursion(Array1D array, int K)
{
Array2D result;
if (array.empty() || K <= 0) { return result; }
if (array.size() < K) {
result.push_back(array); /** @warning maybe exclude it */
return result;
}
Array1D cur(1);
for (int i = 1; i <= array.size(); i++) {
Array1D::size_type size = cur.size();
Array1D temp;
/** @bug has some problems */
for (int j = 0; j < size; j++) {
temp.push_back(cur[j]);
temp.push_back(array[i]);
if (temp.size() == K) { result.push_back(temp); }
else { cur.push_back(array[i]); }
}
}
return result;
}
Array2D CombinationByBinary(Array1D array, int K)
{
Array2D result;
if (array.empty() || K <= 0) { return result; }
if (array.size() < K) {
result.push_back(array); /** @warning maybe exclude it */
return result;
}
/** @warning sort or not */
Array1D temp;
int begin = (1 << K) - 1, end = (1 << array.size()) - (1 << (array.size() - K));
for (int bit = begin; bit <= end; bit = NextBit(bit)) {
temp.clear();
for (int i = 0; i < array.size(); i++) {
if (bit & (1 << i)) {
temp.push_back(array[i]);
}
}
result.push_back(temp);
}
return result;
}
static void CombinationByDecreaseHelper(Array1D &array, int left, int count,
Array1D &temp, Array2D &result)
{
for (int i = left; i >= count; i--) {
temp[count - 1] = array[i - 1];
if (count > 1) {
CombinationByDecreaseHelper(array, i - 1, count - 1, temp, result);
}
else {
result.push_back(temp);
}
}
}
static void CombinationByIncreaseHelper(Array1D &array, int left, int count,
Array1D &temp, Array2D &result)
{
for (int i = left; i < array.size() + 1 - count; i++) {
temp[count - 1] = array[i];
if (count - 1 == 0) {
result.push_back(temp);
}
else {
CombinationByIncreaseHelper(array, i + 1, count - 1, temp, result);
}
}
}
static void PermutationUniqueHelper(Array1D &array, int index, Array2D &result)
{
if (index == array.size()) {
result.push_back(array);
return;
}
for (int i = index; i < array.size(); i++) {
if (HasSameElement(array, index, i, array[i])) {
std::swap(array[index], array[i]);
PermutationUniqueHelper(array, index + 1, result);
std::swap(array[index], array[i]);
}
}
}
static void CombinationHelper(Array1D &array, int left, int right, int k,
Array1D &temp, Array2D &result)
{
assert(!array.empty());
assert(left >= 0 && right >= 0);
if (right - left + 1 < k) { return; }
if (k == 0) {
result.push_back(temp);
return;
}
temp.push_back(array[left]);
CombinationHelper(array, left + 1, right, k - 1, temp, result);
temp.pop_back();
CombinationHelper(array, left + 1, right, k, temp, result);
}
static void CombinationVer2Helper(Array1D &array, int left, int right, int k,
Array1D &temp, Array2D &result)
{
assert(!array.empty());
assert(left >= 0 && right >= 0);
if (k == 0) {
result.push_back(temp);
return;
}
for (int i = left; i <= right - k + 1; i++) {
temp.push_back(array[i]);
CombinationVer2Helper(array, i + 1, right, k - 1, temp, result);
temp.pop_back();
}
}
Array2D ComputeIDX(const Mat& IDX) {
assert(IDX.type() == CV_32S);
assert(IDX.rows > 0 && IDX.cols > 0);
std::unordered_map<int, Array1D> hash;
std::vector<int> hash_keys;
int idx_num = 0;
for (int i = 0; i < IDX.cols; i++) {
if (!hash.count(IDX.at<int>(i))) {
hash_keys.push_back(IDX.at<int>(i));
}
hash[IDX.at<int>(i)].push_back(i + 1);
}
std::sort(hash_keys.begin(), hash_keys.end());
Array2D result;
for (int i = 0; i < hash_keys.size(); i++) {
result.push_back(hash[hash_keys[i]]);
}
return result;
}
