Why is method A flawed compared to B for UVa online judge 100 (3n+1)?

Simply changing from Swap Method A to Swap Method B, the UVa judge goes from 'Wrong Answer' to 'Accepted'. Why is that? I thank you all in advance for your responses.

import java.io.IOException;
import java.util.StringTokenizer;

/**
 * @author Coder47 
 * Another solution to 3n+1 (UVa ID: 100)
 */
class Main {
    public static int[] cache = new int[1000000];
    static String ReadLn (int maxLg)  // utility function to read from stdin
    {
        byte lin[] = new byte [maxLg];
        int lg = 0, car = -1;

        try
        {
            while (lg < maxLg)
            {
                car = System.in.read();
                if ((car < 0) || (car == '\n')) break;
                lin [lg++] += car;
            }
        }
        catch (IOException e)
        {
            return (null);
        }

        if ((car < 0) && (lg == 0)) return (null);  // eof
        return (new String (lin, 0, lg));
    }

    public static void main(String[] args) {
        Main myWork = new Main();  // create a dynamic instance
        myWork.Begin();            // the true entry point
    }

    void Begin() {
        String input;
        StringTokenizer idata;
        // corresponds to swap method A
        int a, b, temp, cycle, cycleMax;
        // corresponds to swap method B
        // int a, b, min, max, cycle, cycleMax;

        while ((input = Main.ReadLn(255)) != null)
        {
            idata = new StringTokenizer(input);
            a = Integer.parseInt(idata.nextToken());
            b = Integer.parseInt(idata.nextToken());
            // swap method A
            if (b < a) {
                temp = a;
                a = b;
                b = temp;
            }

            // swap method B
            // min = Math.min(a, b);
            // max = Math.max(a, b);
            cycleMax = 0;
            // corresponds to swap method A
            for (int i = a; i <= b; i++)
            // corresponds to swap method B
            // for ( int i = min; i <= max; i++)
            {
                cycle = calculateCycle(i);
                if (cycle > cycleMax) {
                    cycleMax = cycle;
                }
            }
            System.out.println (a + " " + b + " " + cycleMax);
        }
    }

    public int calculateCycle(int n) {
        return calculateCycleHelper(n, 1);
    }

    public int calculateCycleHelper(int n, int cycleNum) {
        if (n == 1) {
            return cycleNum;
        } else {
            return calculateCycleHelper(next(n), cycleNum + 1);
        }
    }

    public int next(int n) {
        if (n % 2 == 0) {
            n = n/2;
        }
        else {
            n = 3*n+1;
        }
        return n;
    }
}

Please overlook the efficiency and other related issues of the code, since that is not the issue here.

It's because if (a < b) says the opposite of what you want. You need to swap the elements if b < a, because in the for loop

for (int i = a; i <= b; i++)

you want a to be less than b.

EDIT

For your updated question, the answer is that it's because the judge is checking the output. If you swap a and b the output from the line

 System.out.println (a + " " + b + " " + cycleMax);

changes, so the judge does not accept it.