void calculate2(int i,int j,int w[])
{
if(i==0||j==0)
return ;
if(K[i-1][j]==K[i][j])
calculate2(i-1,j,w);
else
{
calculate2(i-1,j-w[i],w);
nib[i]=1;
}
}
/** assumes given postfix expression is valid */
int evaluatePostfixExpression( char *expr ){
//create the stack
stackNode2Ptr stack = malloc(sizeN);
int x, y;
int i = 0;
char c = expr[i];
//read entire expression
while (c != '\0' && i < 80){
//check what if c is digit or operator
if (isdigit(c)){
// c is a number, so push2 it onto stack
x = c - '0';
push2(&stack, x);
} else {
/* c must be an operator,
* so have to pop2 two elements from the stack and
* apply the operation */
x = pop2(&stack);
y = pop2(&stack);
push2(&stack, calculate2(x, y, c));
}
c = expr[++i];
}
return pop2(&stack);
}
int main()
{
int i,sum,c,oxsum,nisum,ox,ni,n;
int oxygen[1001],nitrogen[1001],weight[1001];
scanf("%d",&c);
while(c--)
{
scanf("%d %d",&ox,&ni);
scanf("%d",&n);
oxsum=nisum=0;
for(i=1;i<=n;i++)
{
scanf("%d %d %d",&oxygen[i],&nitrogen[i],&weight[i]);
oxsum+=oxygen[i];
nisum+=nitrogen[i];
}
// col=(ox>ni)?ox:ni;
memset(oxb,0,sizeof(oxb));
memset(nib,0,sizeof(nib));
knapsack(oxygen,weight,n,oxsum-ox);
printk(n,oxsum-ox);
calculate(n,ox,oxygen);
knapsack(nitrogen,weight,n,nisum-ni);
calculate2(n,ni,nitrogen);
print(oxb,n);
print(nib,n);
sum=0;
for(i=1;i<=n;i++)
if(oxb[i]==0 || nib[i]==0)
sum+=weight[i];
printf("%d\n",sum);
}
return 0;
}
/*******************************************************
* calculate
* Calculates the result of the node of a specific cut
* This calculate ignores negation at inputs (NOT ALWAYS WORKS)
* *FUNCTION OF ADDER4 and ADDER_K_C
*
* @PARAMS:
* node: Node to calculate truth table for
* aigraph: AIG to be used
* @RETURN: Function value at current node
********************************************************/
unsigned long long CutFunction::calculate2(unsigned node){
node = node & 0xFFFFFFFE;
//printf("CURRENT NODE: %d\n", node);
//Check to see if primary input
std::map<unsigned int, unsigned long long>::iterator nvit;
nvit = m_NodeValue.find((unsigned int) node);
if(nvit != m_NodeValue.end()){
//printf("VAL FOUND: %8llx\n", nvit->second);
return nvit->second;
}
//Fix Negative edges for cuts
unsigned node1, node2, child1, child2;
child1 = m_AIG->getChild1(node);
child2 = m_AIG->getChild2(node);
node1 = child1 & 0xFFFFFFFE;
node2 = child2 & 0xFFFFFFFE;
//Recurse until primary input;
unsigned long long result1 = calculate2(node1);
unsigned long long result2 = calculate2(node2);
//Handle Inverters only at points not at the input
//printf("CHILDREG %u %u\n", child1, child2);
if(child1 & 0x1){
nvit = m_NodeValueIn.find((unsigned int) node1);
if(nvit == m_NodeValueIn.end()){
result1 = ~result1;
//printf("CHILD INVERTED: %d\n", node1);
}
else{
//printf("CHILD NOT INVERTED: %d\n", node1);
}
}
if(child2 & 0x1){
nvit = m_NodeValueIn.find((unsigned int) node2);
if(nvit == m_NodeValueIn.end()){
result2 = ~result2;
//printf("CHILD INVERTED: %d\n", node2);
}
else{
//printf("CHILD NOT INVERTED: %d\n", node2);
}
}
//AND Operation
//printf("Node %d IN: %d %d\n", node, child1, child2);
//printf("c1: %8llx\n", result1);
//printf("c2: %8llx\n", result2);
unsigned long long result = result1 & result2;
//printf("r : %8llx\n\n", result);
m_NodeValue[node] = result;
return result;
}
/*******************************************************
* processAIGCuts_Perm
* Process each cut of each node
* Compares the result with library to see if there
* is a match in function
*
* Takes into account permutation at this level
********************************************************/
void CutFunction::processAIGCuts_Perm(bool np){
printf("[CutFunction] -- Calculating Function of Cuts Permutation Mode\n");
//Go through each node and process all the cuts
unsigned size = m_AIG->getSize() + m_AIG->getInputSize() + 1;
for(unsigned int i = m_AIG->getInputSize()+1; i < size; i++){
unsigned node = i * 2;
//printf("############################################################################################################\n");
//printf("--------------------------------\nProcessing node %d\n", node);
std::list<std::set<unsigned> > cutList;
std::list<std::set<unsigned> >::iterator cuts;
m_CutEnumeration->getCuts(i, cutList);
//Go through each cut of the node
for(cuts = cutList.begin(); cuts != cutList.end(); cuts++){
//Skip trivial cut
unsigned int inputSize = cuts->size();
if(inputSize < 5)
continue;
//Permutation of indexes
unsigned int* permutation = setPermutation(inputSize);
std::set<unsigned>::iterator cutIT;
//printf("NODE %d\t", i);
//printf("CUT: ");
std::vector<unsigned> gateInput;
for(cutIT = cuts->begin(); cutIT != cuts->end(); cutIT++)
{
//printf("%d ", *cutIT);
gateInput.push_back(*cutIT);
}
gateInput.push_back(node);
//printf("\n");
//P-Equivalence Check
//Permutation of indexes
std::set<unsigned long long> keyVals;
do{
/*printf("Permutation:\n");
for(unsigned int i = 0; i < inputSize; i++){
printf("%d ", permutation[i]);
}
printf("\n");
*/
int pIndex= 0; //Index for permutation
//printf("\n\nInputSize: %d\n", inputSize);
//Set the assignments for the inputs
for(cutIT = cuts->begin(); cutIT != cuts->end(); cutIT++){
unsigned int permVal = permutation[pIndex];
unsigned long long input = m_Xval[permVal];
m_NodeValue[*cutIT] = input;
m_NodeValueIn[*cutIT] = input;
//printf("CUT: %d\tIV: %llx\n", *cutIT, input);
pIndex++;
}
//Calculate the output at each node up to the current node
calculate2(node);
unsigned long long functionVal = m_NodeValue[node];
unsigned long long negateVal = ~(functionVal);
//printf("OUTPUT: %x\n", negate);
//N-Equivalence Check the negation of the output
//Count the number of occurances for each unique function
//Store the function that's smaller, whether negate or nodevalue
unsigned long long functionKey = functionVal;
if(negateVal < functionVal)
functionKey = negateVal;
//printf("KEY CHOSEN: %llx\n", functionKey);
keyVals.insert(functionKey);
// printf("FUNCTION: %llx\n", functionVal);
// printf("NEGATED: %llx\n\n", negateVal);
std::map<unsigned long long, int>::iterator fcit;
fcit = m_FunctionCount.find(functionKey);
if(fcit == m_FunctionCount.end())
m_FunctionCount[functionKey] = 1;
else
fcit->second++;
m_NodeValue.clear();
m_NodeValueIn.clear();
}while(std::next_permutation(permutation, permutation+inputSize));
delete [] permutation;
m_UniqueFunction[keyVals].push_back(gateInput);
}
}
}
int Solver2()
{
return calculate2(0, 1, 4000000);
}
int calculate2(int current, int next, int limit)
{
return current > limit ? 0 : (current%2 == 0 ? current : 0) + calculate2(next, current + next, limit);
}
