There are points to keep in mind for each approach, and there may not be a clear winner.
If not constant, a protected field allows the subclass to modify parent class state directly. This means a subclass may be able to violate the parent's invariants or validations. State may be able to change at inopportune times, which may cause problems (or it may not).
In other words, this approach might cause a class to behave inconsistently, possibly in a bad way.
That being said, some state might be treated as volatile and it is okay for it to change whenever you want.
This is actually not much different. Methods can be overridden as long as they are not marked as un-overridable (e.g. final, non-virtual). The difference is while a field can be changed directly, a getter/setter combination can enforce invariants and validations on the field transparently.
Does the state represent a property of the base class directly, or does it happen to be that all subclasses need the state but it does not really belong to the base class? For example, let as assume that all animals can speak. Animal knows it can speak, but the how belongs in the subclass. Maybe an abstract getter method is appropriate: Animal can use it, but the actual implementation must be defined in each subclass.
If the state does not change, you may also be able to define a constant in the base class. Maybe the subclass passes a value to the base class constructor which then sets it in stone in that constant. This allows the base class to use the constant as well because it is defined in the base class.
There is no one way to do this, and understanding the right way for a given situation requires experience. Hopefully this helps explain why each option works and how they are different.