ProblemE CF465

import java.util.*;

public class ProblemE {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        String s=sc.next();
        int P=sc.nextInt();
        int M=sc.nextInt();

        Deque<Character> stack = new ArrayDeque<Character>();
        Deque<Character> queue = new ArrayDeque<Character>();

        for (Character c:s.toCharArray()){
            if ("0123456789".contains(c.toString())){
                queue.addLast(c);
            }
            else if (c=='('){
                stack.addLast(c);
            }
            else if (c==')'){
                Character pop=null;
                while (true){
                    pop=stack.removeLast();
                    if (pop=='(') break;
                    queue.addLast(pop);
                }
            }
            else{
                stack.addLast(c);
            }
        }
        while (!stack.isEmpty()){
            queue.addLast(stack.removeLast());
        }

        Deque<Node> nStack = new ArrayDeque<Node>();
        while (!queue.isEmpty()){
            Character c = queue.removeFirst();
            if (c=='?'){
                Node r = nStack.removeLast();
                Node l = nStack.removeLast();
                nStack.addLast(new Node(l,r));
            }
            else{
                nStack.addLast(new Node(Integer.parseInt(c.toString())));
            }
        }

        if (P>100){
            Node root = nStack.removeFirst();
            postOrder(root);
            System.out.println(root.maxUsingKM[M]);
        }
        else{
            Node root = nStack.removeFirst();
            postOrder(root);
            System.out.println(root.maxUsingKP[P]);
        }

    }

    static void postOrder(Node root){
        if (root.left==null){
            visit(root);
        }
        else{
            postOrder(root.left);
            postOrder(root.right);
            visit(root);
        }

    }


    static void visit(Node root){

        if (root.type==nType.NUM){
            root.maxUsingKP[0]=root.num;
            root.minUsingKP[0]=root.num;
            root.maxUsingKM[0]=root.num;
            root.minUsingKM[0]=root.num;
        }
        else{
            //ovisi koliko pluseva i minusa koristimo
            for (int p=0;p<=100;p++){
                for (int left=0;left<p;left++){
                    //stavimo plus
                    root.maxUsingKP[p]=Math.max(root.maxUsingKP[p], root.left.maxUsingKP[left]+root.right.maxUsingKP[p-left-1]);
                    root.minUsingKP[p]=Math.min(root.minUsingKP[p], root.left.minUsingKP[left]+root.right.minUsingKP[p-left-1]);
                }
                for (int left=0;left<=p;left++){
                    //stavimo minus
                    root.maxUsingKP[p]=Math.max(root.maxUsingKP[p], root.left.maxUsingKP[left]-root.right.minUsingKP[p-left]);
                    root.minUsingKP[p]=Math.min(root.minUsingKP[p], root.left.minUsingKP[left]-root.right.maxUsingKP[p-left]);
                }
            }
            for (int p=0;p<=100;p++){
                for (int left=0;left<=p;left++){
                    //stavimo plus
                    root.maxUsingKM[p]=Math.max(root.maxUsingKM[p], root.left.maxUsingKM[left]+root.right.maxUsingKM[p-left]);
                    root.minUsingKM[p]=Math.min(root.minUsingKM[p], root.left.minUsingKM[left]+root.right.minUsingKM[p-left]);
                }
                for (int left=0;left<p;left++){
                    //stavimo minus
                    root.maxUsingKM[p]=Math.max(root.maxUsingKM[p], root.left.maxUsingKM[left]-root.right.minUsingKM[p-left-1]);
                    root.minUsingKM[p]=Math.min(root.minUsingKM[p], root.left.minUsingKM[left]-root.right.maxUsingKM[p-left-1]);
                }
            }
        }

    }

    static class Node{
        nType type;
        int num;
        Node left;
        Node right;

        int size;
        int[] maxUsingKP=new int[101];
        int[] minUsingKP=new int[101];
        int[] maxUsingKM=new int[101];
        int[] minUsingKM=new int[101];
        {
            Arrays.fill(maxUsingKP, -1_000_000_000);
            Arrays.fill(minUsingKP, +1_000_000_000);
            Arrays.fill(maxUsingKM, -1_000_000_000);
            Arrays.fill(minUsingKM, +1_000_000_000);
        }

        public Node(int num){
            type=nType.NUM;
            this.num=num;
            this.size=0;
        }
        public Node(Node left, Node right){
            type=nType.OP;
            this.left=left;
            this.right=right;
            this.size=left.size+right.size+1;
        }
    }
    enum nType{
        NUM,OP
    }
}