void test()
{
TFile* fFakeFactorW = TFile::Open("/afs/cern.ch/user/j/jsauvan/workspace/Projects/Htautau_Run2/Studies/FakeRate/ComputeFakeRates/plots/FakeFactors_Data_HighMT_2D/FakeFactors_Data_HighMT_2D.root");
TFile* fFakeFactorQCD = TFile::Open("/afs/cern.ch/user/j/jsauvan/workspace/Projects/Htautau_Run2/Studies/FakeRate/ComputeFakeRates/plots/FakeFactors_Data_QCDSS_2D/FakeFactors_Data_QCDSS_2D.root");
TFile* fMtCorrection = TFile::Open("/afs/cern.ch/user/j/jsauvan/workspace/Projects/Htautau_Run2/Studies/FakeRate/ComputeMTCorrection/results/mtCorrections.root");
TFile* fFractions = TFile::Open("/afs/cern.ch/user/j/jsauvan/workspace/Projects/Htautau_Run2/Studies/FakeRate/ComputeBackgroundFractions/results/backgroundFraction_Iso_Medium_mvis_vs_mt.root");
TH2F* fakeFactorW = (TH2F*)fFakeFactorW->Get("FakeFactors_Data_HighMT_2D_Iso_Medium_InvertIso_Medium_tau_pt_vs_decayMode");
TH2F* fakeFactorQCD = (TH2F*)fFakeFactorQCD->Get("FakeFactors_Data_QCDSS_2D_Iso_Medium_InvertIso_Medium_tau_pt_vs_decayMode");
TGraph* mtCorrection = (TGraph*)fMtCorrection->Get("mt_correction");
TH2F* fractionW = (TH2F*)fFractions->Get("h_backgroundFraction_Iso_Medium_mvis_vs_mt_W_Nom");
TH2F* fractionQCD = (TH2F*)fFractions->Get("h_backgroundFraction_Iso_Medium_mvis_vs_mt_QCD_Nom");
TH2F* fractionTT = (TH2F*)fFractions->Get("h_backgroundFraction_Iso_Medium_mvis_vs_mt_TT_Nom");
TH2F* fractionVV = (TH2F*)fFractions->Get("h_backgroundFraction_Iso_Medium_mvis_vs_mt_VV_Nom");
TH2F* fractionZJ = (TH2F*)fFractions->Get("h_backgroundFraction_Iso_Medium_mvis_vs_mt_ZJ_Nom");
//wrappers
WrapperTH2F* wFakeFactorW = new WrapperTH2F(*fakeFactorW, "FF_W");
WrapperTH2F* wFakeFactorQCD = new WrapperTH2F(*fakeFactorQCD, "FF_QCD");
WrapperTGraph* wMtCorrection = new WrapperTGraph(*mtCorrection, "MT_Corr");
WrapperTH2F* wFractionW = new WrapperTH2F(*fractionW, "f_W");
WrapperTH2F* wFractionQCD = new WrapperTH2F(*fractionQCD, "f_QCD");
WrapperTH2F* wFractionTT = new WrapperTH2F(*fractionTT, "f_TT");
WrapperTH2F* wFractionVV = new WrapperTH2F(*fractionVV, "f_VV");
WrapperTH2F* wFractionZJ = new WrapperTH2F(*fractionZJ, "f_ZJ");
// formulas
TFormula mtCorr("mtCorr", "x[0]*x[1]");
WrapperTFormula* wFakeFactorWCorr = new WrapperTFormula(mtCorr, "FF_WCorr");
TFormula combination("combination", "x[0]*x[2]+x[1]*(x[3]+x[4]+x[5]+x[6])");
WrapperTFormula* wFakeFactorComb = new WrapperTFormula(combination, "FF_Comb");
// fake factor
// tau_pt = 0
// tau_decay = 1
// mt = 2
// mvis = 3
FakeFactor* factor = new FakeFactor();
factor->addNode(wFakeFactorW, {}, {0,1});
factor->addNode(wFakeFactorQCD, {}, {0,1});
factor->addNode(wMtCorrection, {}, {2});
factor->addNode(wFractionW, {}, {3,2});
factor->addNode(wFractionQCD, {}, {3,2});
factor->addNode(wFractionTT, {}, {3,2});
factor->addNode(wFractionVV, {}, {3,2});
factor->addNode(wFractionZJ, {}, {3,2});
factor->addNode(wFakeFactorWCorr, {0,2}, {});
factor->addNode(wFakeFactorComb, {1,8,4,3,5,6,7}, {});
TFile* file = TFile::Open("test.root", "recreate");
file->WriteObject(factor, "ff");
file->Close();
std::cout<<"Done\n";
}
/**
* Generuje naprzemienną kombinację liniową, tj. P_0 - P_1 + P_2 - P_3...
*
* @param P ciąg wielomianów ortogonalnych do wygenerowania kombinacji
*/
static combination alternate(const orthonomial &P) {
sequence t(P.n + 1);
for (uint i = 0; i <= P.n; i++) {
t[i] = i % 2 == 0 ? 1 : -1;
}
return combination(P, t);
}
void combination(int n, int c, int combs[]){
if(c == 0){
int i;
for(i=0; i<size; i++){
printf("%d ",combs[i]);
}
printf("\n");
return;
}
if(n==0)
return;
combs[c-1] = n;
combination(n-1, c-1, combs);
combination(n-1, c, combs);
}
int main(void){
int n;
int i=1;
scanf("%d" , &n);
for(i=1;i<=n;i++){
int arr[i];
size = i;
combination(n, i, arr);
}
}
void FPTree::test()
{
ItemSet itemsetA;
itemsetA.item.push_back("2");
ItemSet itemsetB;
itemsetB.item.push_back("1");
itemsetB.item.push_back("3");
combination(&itemsetA, &itemsetB, 1);
}
vector<vector<int> > combinationSum2(vector<int> &num, int target)
{
vector<int> vecTmp;
m_vecRet.clear();
sort(num.begin(), num.end());
combination(num, 0, vecTmp, target);
return m_vecRet;
}
int main() {
int t,h,i;
for (scanf("%d",&t);t;t--) {
scanf("%d%d",&n,&h);
for (i=0;i<n;i++) hamming[i]='0';
hamming[n]='\0';
combination(0,h);
if (t>1) puts("");
}
}
// フォーカードを狙う
int four_of_a_kind(Handcard hd[], Cards remain_card, Cards hand_card, Cards deck_card, int cg)
{
int k1, k2;
int reqire_num;
int change_num = CHNG - cg;
int min_num;
int min_pos;
int flag = 0; // 役が狙えるかどうかのフラグ
double exp_num[13] = {0};
double numerator, denominator;
for ( k1 = 0; k1 < 13; k1++) {
reqire_num = 4 - hand_card.num[k1];
if ( deck_card.num[k1] < reqire_num || change_num < reqire_num ) { continue; }
flag = 1;
if ( deck_card.amount < change_num ) {
exp_num[k1] = 1;
} else {
denominator = combination(deck_card.amount, change_num);
numerator = combination(deck_card.amount - deck_card.num[k1], change_num - reqire_num);
exp_num[k1] = numerator / denominator;
}
}
// 手札に確率の反映
for ( k1 = 0; k1 < HNUM; k1++ ) {
hd[k1].exp[FOUR_OF_A_KIND] = (exp_num[hd[k1].num] * P7);
}
if ( flag ) {
bubble_sort_role(hd, HNUM, FOUR_OF_A_KIND);
min_num = remain_card.num[hd[0].num];
min_pos = hd[0].pos;
for ( k1 = 1; k1 < HNUM; k1++ ) {
if ( remain_card.num[hd[k1].num] < min_num ) {
min_num = remain_card.num[hd[k1].num];
min_pos = hd[k1].pos;
}
}
return min_pos;
}
return -1;
}
void combination(vector<int> &num, int beg, int target, vector<int> &tmp, vector<vector<int> > &ret) {
if(target < 0) return;
if(target == 0) {ret.push_back(tmp); return;}
for(int i = beg; i < num.size();) {
int t = num[i];
tmp.push_back(t);
combination(num, i+1, target - t, tmp, ret);
tmp.pop_back();
while(num[++i] == t && i < num.size());
}
}
void FPTree::GenerateFrequentItemSets(FPNode* fpNode, ItemSet* itemSet, vector<FPItem*> fpItems)
{
if(fpNode == NULL)
{
return;
}
// 单个路径
if(fpNode -> childs != NULL && fpNode -> childs -> siblings == NULL)
{
ItemSet itemSetA;
FPNode* child = fpNode -> childs;
while(child != NULL)
{
itemSetA.item.push_back(child -> fpData -> data);
if(itemSetA.support > child -> fpData -> support)
{
itemSetA.support = child -> fpData -> support;
}
child = child -> childs;
}
combination(&itemSetA, itemSet, (int)itemSetA.item.size());
}
else
if(fpNode -> childs == NULL && itemSet -> item.size() >=2)
{
for(int i = 0; i < itemSet -> item.size(); i++)
{
cout << itemSet -> item[i] << " ";
}
cout << endl;
}
else
{
for(int i = (int)fpItems.size() - 1; i >= 0; i--)
{
ItemSet itemSetB;
string data = fpItems[i] -> itemData;
itemSetB.item.push_back(data);
itemSetB.support = fpItems[i] -> support;
if(itemSet != NULL)
{
for(int j = 0; j < itemSet -> item.size(); j++)
{
itemSetB.item.push_back(itemSet -> item[j]);
}
}
FPNode* root = NewNode("$", 0);
vector<FPItem*> childFpItems;
BuildConditionFPItems(fpItems[i], childFpItems);
BuildConditionTree(fpItems[i], &root, childFpItems);
GenerateFrequentItemSets(root, &itemSetB, childFpItems);
}
}
}
int main() {
scanf("%d", &n);
while (n) {
for (int i = 0; i < n; i++)
scanf("%d", &input[i]);
combination(0, 0, n, 6);
scanf("%d", &n);
if (n)
printf("\n");
}
}
void combination(int k, int n, vector<int>& v, vector<vector<int>>& ret, int beg){
if(k == 0 && n == 0){
ret.push_back(v);
return;
}
for(int i = beg; i < 10 && i <= n; i++){
v.push_back(i);
combination(k - 1, n - i, v, ret, i + 1);
v.pop_back();
}
}
void combination(int n, int k, int start, vector<int> &path, vector<vector<int>> &result) {
if (k == 0) {
result.push_back(path);
return;
}
for (int i = start; i <= n; ++i) {
path.push_back(i);
combination(n, k-1, i+1, path, result);
path.pop_back();
}
}
vector<vector<int>> combine(int n, int k) {
vector<vector<int>> res;
if(n<k || k<=0 || n<=0)
return res;
vector<int> p;
combination(n,k,1,p,res);
return res;
}
int main()
{
int j, k;
printf("1\n1 1\n");
for(j = 2; j <= 5; j++){
for(k = 0; k <= j; k++){
printf("%d ", combination(j, k));
}
printf("\n");
}
return 0;
}
void Solution::combination(vector<vector<int> > &result, vector<int> sol, int k, int n)
{
if (sol.size() == k && n == 0) { result.push_back(sol); return ; }
if (sol.size() < k) {
for (int i = sol.empty() ? 1 : sol.back() + 1; i <= 9; ++i) {
if (n - i < 0) break;
sol.push_back(i);
combination(result, sol, k, n - i);
sol.pop_back();
}
}
}
vector<vector<int> > combinationSum2(vector<int> &num, int target) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
vector<vector<int> > ret;
if(num.empty())
return ret;
int n = num.size();
sort(num.begin(),num.end());
vector<int> vec(100);
combination(ret,num,-1,n,target,vec,0,0);
return ret;
}
void iterateThroughDimensions(int level,
int dims_left,
SGNodes<Scalar,DIM> & cubPointsND,
Teuchos::Array<Scalar> & partial_node,
Scalar partial_weight)
{
int l = level;
int d = DIM;
int add_on = d - dims_left;
int start = dims_left > 1 ? 1 : (int)std::max(1, l);
int end = l + add_on;
for(int k_i = start; k_i <= end; k_i++)
{
/*******************
** Slow-Gauss
********************/
int order1D = 2*k_i-1;
/*******************
** Fast-Gauss
********************/
//int order1D = (int)pow(2,k_i) - 1;
int cubDegree1D = 2*order1D - 1;
CubatureDirectLineGauss<Scalar> Cub1D(cubDegree1D);
FieldContainer<Scalar> cubPoints1D(order1D, 1);
FieldContainer<Scalar> cubWeights1D(order1D);
Cub1D.getCubature(cubPoints1D, cubWeights1D);
for(int node1D = 0; node1D < order1D; node1D++)
{
Teuchos::Array<Scalar> node(d-dims_left+1);
node[d-dims_left] = cubPoints1D(node1D,0);
for(int m = 0; m < d-dims_left; m++)
node[m] = partial_node[m];
Scalar weight = cubWeights1D(node1D)*partial_weight;
if(dims_left != 1)
{
iterateThroughDimensions(l - k_i, dims_left-1, cubPointsND, node, weight);
}
else
{
weight = pow(-1.0, end - k_i)*combination(d-1, k_i - l)*weight;
cubPointsND.addNode(&node[0], weight);
}
}
}
}
void AddAllCombinations(const vector<int>& S, size_t Length, vector<vector<int>>& Result)
{
vector<int> combination(Length, 0);
vector<bool> selection(S.size(), false);
for (size_t i = 0; i < Length; ++i)
{
selection[i] = true;
}
do
{
Result.push_back(GetSubset(S, selection));
} while (NextSelection(selection));
}
vector<int> getRow(int rowIndex)
{
vector<int> line = {1}; // first member.
if(rowIndex == 0)
return line;
// add other members if rowIndex > 0.
for(int i = 1; i < rowIndex; ++i) {
line.push_back(combination(rowIndex, i));
}
line.push_back(1); // last member.
return line;
}
int count(int n, int h) {
long long ret = 1;
for (int p = 2; p <= n/p; ++p) {
int q = 0;
while (n % p == 0) {
++q;
n /= p;
}
ret = ret * combination(h - 1 + q, q) % MOD;
}
if (n > 1) {
ret = ret * h % MOD;
}
return (int) ret;
}
void combination(string &tmp, int cur, string &digits)
{
if (cur == digits.size()) {
string elem = tmp;
result.push_back(elem);
//cout << elem << endl;
return;
}
auto ret = PhoneMap.equal_range(digits[cur]);
for (auto iter = ret.first; iter != ret.second; iter++) {
tmp.push_back(iter->second);
combination(tmp, cur + 1, digits);
tmp.pop_back();
}
}
void combination(vector<int>& nums, vector<int> path, int start, int k)
{
if (path.size() == k)
res.push_back(path);
int i = start;
while (i < nums.size())
{
path.push_back(nums[i]);
combination(nums, path, i + 1, k);
path.pop_back();
i++;
while (i < nums.size() && nums[i] == nums[i-1])
i++;
}
}
int main() {
int z = combination(0, 8);
int a = combination(1, 8);
int b = combination(2, 8);
int c = combination(3, 8);
int d = combination(4, 8);
int h = combination(5, 8);
int e = combination(6, 8);
int f = combination(7, 8);
int g = combination(8, 8);
printf("%d\n", z);
printf("%d\n", a);
printf("%d\n", b);
printf("%d\n", c);
printf("%d\n", d);
printf("%d\n", h);
printf("%d\n", e);
printf("%d\n", f);
printf("%d\n", g);
return 0;
}
int ways_rec(int n, int k)
{
int res;
/*end condition for ways_rec function*/
if(k>n)
res=0;
else
{
printf("%d one stairs %d two stairs",n-k,k);
res=combination(n,k);
printf("=>%d different way \nOR\n",res);
res+=ways_rec(n-1,k+1);
}
return res;
}
void combination(int n,int k,int index,vector<int>& p,vector<vector<int>>& res)
{
if(p.size()==k)
{
res.push_back(p);
return;
}
for(int i=index; i<=n; i++)
{
p.push_back(i);
combination(n,k,i+1,p,res);
p.pop_back();
}
return;
}
int main(){
int n;
int *min, cur[20];
int i, j;
scanf("%d", &n);
min = new int[1 << n]();
for (i = 1, j = 0; j < n; j++, i <<= 1)
scanf("%d", &min[i]);
for (i = 1; i < n; i++){
for (j = 0; j < n; j++)
scanf("%d", &cur[j]);
combination(min, cur, n, i+1, 0, 0, 0);
}
printf("%d\n", min[(1 << n) - 1]);
delete[] min;
return 0;
}
BitVector<dim> Subspace<dim>::representative
(const BitVector<dim>& v) const
{
assert(v.size()==rank());
// get projection to subspace expressed in d_basis
BitVector<dim> pv = v;
pv.slice(d_support);
assert(pv.size()==dimension()); // |slice| set it to |d_support.count()|
// expand that linear combination to an element of $(Z/2Z)^n$
BitVector<dim> w = combination(d_basis,rank(),pv.data());
assert(w.size()==rank());
return v+w; // set |r| to original vector minus (or plus) correction |w|
}
int *readBinary(int bits, int num, int *returnSize) {
int n = combination(bits, num);
int *ret = malloc(sizeof(int) * n);
Ctx ctx, *p = &ctx;
initCtx(p, bits, num);
int *st = malloc(sizeof(int) * num);
int i;
for (i = 0; next(p); i++) {
snapshot(p, st);
ret[i] = buildFromBits(st, num);
}
*returnSize = n;
free(st);
finitCtx(p);
return ret;
}
void combination(int min[], int cur[], int n, int k, int idx, int i, int from){
if (k == i){
int j;
int tmp = idx;
bool check = false;
for (j = 0; tmp; j++){
if (tmp % 2){
int value = min[idx - (1 << j)] + cur[j];
if (!check || min[idx] > value){
min[idx] = value;
check = true;
}
}
tmp /= 2;
}
}else{
for (; from < n; from++)
combination(min, cur, n, k, idx + (1 << from), i+1, from+1);
}
}
